Merge pull request #3 from atom-community/fixes

Author: aminya

package.json

@@ -13,7 +13,7 @@
     "test": "npm run build.unit && npm run test.only",
     "test.only": "atom --test ./dist/spec",
     "clean": "shx rm -rf dist",
-    "build.unit": "tsc -p ./tsconfig.json || echo done",
+    "build.unit": "tsc -p ./tsconfig.json",
     "dev": "npm run clean && cross-env NODE_ENV=development cross-env BABEL_KEEP_MODULES=true rollup -c -w",
     "build": "npm run clean && cross-env NODE_ENV=production cross-env BABEL_KEEP_MODULES=true rollup -c ",
     "build-commit": "build-commit -o dist",
@@ -82,7 +82,7 @@
     "shx": "^0.3.3",
     "temp": "^0.9.4",
     "typescript": "^4.3.5",
-    "waitsfor": "^0.0.6"
+    "waitit": "^1.0.3"
   },
   "prettier": "prettier-config-atomic"
 }

pnpm-lock.yaml

@@ -13,7 +13,7 @@ const RollupConfig = [
       },
     ],
     // loaded externally
-    external: ["atom", "log4js", "rxjs-compat"],
+    external: ["atom", "log4js", "rxjs-compat/bundles/rxjs-compat.umd.min.js"],
     plugins,
   },
 ]

rollup.config.js

@@ -1,26 +1,24 @@
-import { Range } from "atom"
+import { Range, TextEditor } from "atom"
 import { observeTextEditors } from "@atom-ide-community/nuclide-commons-atom/FileEventHandlers"
 import CodeFormatManager, { SAVE_TIMEOUT } from "../src/CodeFormatManager"
 import UniversalDisposable from "@atom-ide-community/nuclide-commons/UniversalDisposable"
 import temp from "temp"
 import * as config from "../src/config"
-import { waitsFor } from "waitsfor"
-
-const sleep = (n) => new Promise((r) => setTimeout(r, n))
+import { waitFor, sleep } from "./utils"
 
 jasmine.DEFAULT_TIMEOUT_INTERVAL = SAVE_TIMEOUT + 100
 describe("CodeFormatManager", () => {
-  let textEditor
-  let manager
-  let disposables
+  let textEditor: TextEditor
+  let manager: CodeFormatManager
+  let disposables: UniversalDisposable
   beforeEach(async () => {
     manager = new CodeFormatManager()
     disposables = new UniversalDisposable(observeTextEditors())
     temp.track()
     const file = temp.openSync()
     textEditor = await atom.workspace.open(file.path)
   })
-  afterEach(async () => {
+  afterEach(() => {
     manager.dispose()
     disposables.dispose()
   })
@@ -38,10 +36,8 @@ describe("CodeFormatManager", () => {
         ]),
     })
     textEditor.setText("abc")
-    atom.commands.dispatch(atom.views.getView(textEditor), "code-format:format-code")
-    await waitsFor(() => textEditor.getText() === "def", {
-      timeout: SAVE_TIMEOUT,
-    })
+    await atom.commands.dispatch(atom.views.getView(textEditor), "code-format:format-code")
+    await waitFor(() => textEditor.getText() === "def")
   })
   it("format an editor using formatEntireFile", async () => {
     manager.addFileProvider({
@@ -53,10 +49,8 @@ describe("CodeFormatManager", () => {
         }),
     })
     textEditor.setText("abc")
-    atom.commands.dispatch(atom.views.getView(textEditor), "code-format:format-code")
-    await waitsFor(() => textEditor.getText() === "ghi", {
-      timeout: SAVE_TIMEOUT,
-    })
+    await atom.commands.dispatch(atom.views.getView(textEditor), "code-format:format-code")
+    await waitFor(() => textEditor.getText() === "ghi")
   })
   it("formats an editor on type", async () => {
     spyOn(config, "getFormatOnType").and.returnValue(true)
@@ -79,11 +73,9 @@ describe("CodeFormatManager", () => {
     textEditor.setCursorBufferPosition([0, 1])
     textEditor.insertText("b")
     textEditor.insertText("c")
-    await waitsFor(() => textEditor.getText() === "def", {
-      timeout: SAVE_TIMEOUT,
-    })
+    await waitFor(() => textEditor.getText() === "def")
     // Debouncing should ensure only one format call.
-    expect(spy.mock.calls.length).toBe(1)
+    expect(spy.calls.count()).toBe(1)
   })
   it("formats an editor on save", async () => {
     spyOn(config, "getFormatOnSave").and.returnValue(true)
@@ -114,12 +106,11 @@ describe("CodeFormatManager", () => {
       },
     })
     const spy = spyOn(textEditor.getBuffer(), "save")
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     textEditor.save()
     // Wait until the buffer has been saved and verify it has been saved exactly
     // once.
-    await waitsFor(() => spy.mock.calls.length > 0, {
-      timeout: SAVE_TIMEOUT,
-    })
-    expect(spy.mock.calls.length).toBe(1)
+    await waitFor(() => spy.calls.count() > 0)
+    expect(spy.calls.count()).toBe(1)
   })
 })

spec/CodeFormatManager-spec.ts

@@ -0,0 +1,16 @@
+import * as waitit from "waitit"
+
+/** Wait until a function returns true */
+export function waitFor(fn: (...args: any[]) => boolean, timeout = 2500) {
+  const interval = 100 // check very 100 ms
+  return waitit.start({
+    interval,
+    maxTicks: timeout / interval,
+    check: fn,
+  })
+}
+
+/** Sleep for ms */
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

spec/utils.ts

@@ -1,4 +1,4 @@
-import type { Point, TextEditor, TextChange, Disposable } from "atom"
+import type { TextEditor, TextChange, Disposable } from "atom"
 // TODO add to @types/atom
 type AggregatedTextChange = {
   changes: Array<TextChange>
@@ -78,7 +78,7 @@ export default class CodeFormatManager {
 
     // Events from editor actions (saving, typing).
     const editorEvents = observableFromSubscribeFunction((cb) => atom.workspace.observeTextEditors(cb)).mergeMap(
-      (editor) => this._getEditorEventStream(editor)
+      (editor) => _getEditorEventStream(editor)
     )
 
     return (
@@ -97,22 +97,6 @@ export default class CodeFormatManager {
     )
   }
 
-  /** Returns a stream of all typing and saving operations from the editor. */
-  _getEditorEventStream(editor: TextEditor): Observable<FormatEvent> {
-    const changeEvents = observableFromSubscribeFunction((callback) => editor.getBuffer().onDidChangeText(callback))
-
-    // We need to capture when editors are about to be destroyed in order to
-    // interrupt any pending formatting operations. (Otherwise, we may end up
-    // attempting to save a destroyed editor!)
-    const willDestroyEvents = observableFromSubscribeFunction((cb) => atom.workspace.onWillDestroyPaneItem(cb)).filter(
-      (event) => event.item === editor
-    )
-
-    return Observable.merge(changeEvents.map((edit) => ({ type: "type", editor, edit }))).takeUntil(
-      Observable.merge(observeEditorDestroy(editor), willDestroyEvents)
-    )
-  }
-
   _handleEvent(event: FormatEvent): Observable<unknown> {
     const { editor } = event
     switch (event.type) {
@@ -142,14 +126,6 @@ export default class CodeFormatManager {
     }
   }
 
-  // Checks whether contents are same in the buffer post-format, throwing if
-  // anything has changed.
-  _checkContentsAreSame(before: string, after: string): void {
-    if (before !== after) {
-      throw new Error("The file contents were changed before formatting was complete.")
-    }
-  }
-
   // Return the text edits used to format code in the editor specified.
   _formatCodeInTextEditor(editor: TextEditor, range?: Range): Observable<Array<TextEdit>> {
     return Observable.defer(() => {
@@ -197,7 +173,7 @@ export default class CodeFormatManager {
             return Observable.of(firstNonNull)
           }
         })
-        .map(({ _, formatted }) => {
+        .map(({ formatted }) => {
           return [
             {
               oldRange: editor.getBuffer().getRange(),
@@ -270,7 +246,7 @@ export default class CodeFormatManager {
           if (edits.length === 0) {
             return
           }
-          this._checkContentsAreSame(contents, editor.getText())
+          _checkContentsAreSame(contents, editor.getText())
           // Note that this modification is not in a transaction, so it applies as a
           // separate editing event than the character typing. This means that you
           // can undo just the formatting by attempting to undo once, and then undo
@@ -394,5 +370,29 @@ function isBracketPair(typedText: string): boolean {
     return false
   }
   const validBracketPairs: Array<string> = atom.config.get("bracket-matcher.autocompleteCharacters") as any
-  return validBracketPairs.indexOf(typedText) !== -1
+  return validBracketPairs.includes(typedText)
+}
+
+// Checks whether contents are same in the buffer post-format, throwing if
+// anything has changed.
+function _checkContentsAreSame(before: string, after: string): void {
+  if (before !== after) {
+    throw new Error("The file contents were changed before formatting was complete.")
+  }
+}
+
+/** Returns a stream of all typing and saving operations from the editor. */
+function _getEditorEventStream(editor: TextEditor): Observable<FormatEvent> {
+  const changeEvents = observableFromSubscribeFunction((callback) => editor.getBuffer().onDidChangeText(callback))
+
+  // We need to capture when editors are about to be destroyed in order to
+  // interrupt any pending formatting operations. (Otherwise, we may end up
+  // attempting to save a destroyed editor!)
+  const willDestroyEvents = observableFromSubscribeFunction((cb) => atom.workspace.onWillDestroyPaneItem(cb)).filter(
+    (event) => event.item === editor
+  )
+
+  return Observable.merge(changeEvents.map((edit) => ({ type: "type", editor, edit }))).takeUntil(
+    Observable.merge(observeEditorDestroy(editor), willDestroyEvents)
+  )
 }

src/CodeFormatManager.ts

@@ -0,0 +1,32 @@
+// TODO Remove
+
+import type { Disposable } from "atom"
+import { consumeRangeProvider, consumeFileProvider, consumeOnSaveProvider, consumeOnTypeProvider } from "./main"
+import type { CodeFormatProvider } from "./types"
+
+export function consumeLegacyProvider(provider: CodeFormatProvider): Disposable {
+  // Legacy providers used `selector` / `inclusionPriority`.
+  // @ts-ignore legacy API compatability.
+  provider.grammarScopes =
+    provider.grammarScopes ||
+    // @ts-ignore
+    (provider.selector != null ? provider.selector.split(", ") : null)
+  provider.priority =
+    provider.priority != null
+      ? provider.priority
+      : // @ts-ignore
+      provider.inclusionPriority != null
+      ? // @ts-ignore
+        provider.inclusionPriority
+      : 0
+  if ("formatCode" in provider) {
+    return consumeRangeProvider(provider)
+  } else if ("formatEntireFile" in provider) {
+    return consumeFileProvider(provider)
+  } else if ("formatAtPosition" in provider) {
+    return consumeOnTypeProvider(provider)
+  } else if ("formatOnSave" in provider) {
+    return consumeOnSaveProvider(provider)
+  }
+  throw new Error("Invalid code format provider")
+}

src/legacy-provider.ts

@@ -1,7 +1,6 @@
 import type { Disposable } from "atom"
 import type { BusySignalService } from "atom-ide-base"
 import type {
-  CodeFormatProvider,
   RangeCodeFormatProvider,
   FileCodeFormatProvider,
   OnTypeCodeFormatProvider,
@@ -18,32 +17,6 @@ export function activate() {
   codeFormatManager = new CodeFormatManager()
 }
 
-export function consumeLegacyProvider(provider: CodeFormatProvider): Disposable {
-  // Legacy providers used `selector` / `inclusionPriority`.
-  // $FlowIgnore legacy API compatability.
-  provider.grammarScopes =
-    provider.grammarScopes ||
-    // $FlowIgnore
-    (provider.selector != null ? provider.selector.split(", ") : null)
-  provider.priority =
-    provider.priority != null
-      ? provider.priority
-      : // $FlowFixMe(>=0.68.0) Flow suppress (T27187857)
-      provider.inclusionPriority != null
-      ? provider.inclusionPriority
-      : 0
-  if (provider.formatCode) {
-    return consumeRangeProvider(provider)
-  } else if (provider.formatEntireFile) {
-    return consumeFileProvider(provider)
-  } else if (provider.formatAtPosition) {
-    return consumeOnTypeProvider(provider)
-  } else if (provider.formatOnSave) {
-    return consumeOnSaveProvider(provider)
-  }
-  throw new Error("Invalid code format provider")
-}
-
 export function consumeRangeProvider(provider: RangeCodeFormatProvider): Disposable {
   return codeFormatManager.addRangeProvider(provider)
 }
@@ -67,3 +40,6 @@ export function consumeBusySignal(busySignalService: BusySignalService): Disposa
 export function deactivate() {
   codeFormatManager.dispose()
 }
+
+// TODO remove
+export { consumeLegacyProvider } from "./legacy-provider"

src/main.ts

@@ -1,13 +1,13 @@
 {
   "compilerOptions": {
-    "strict": false,
-    "strictNullChecks": false,
-    "noUnusedLocals": false,
-    "noUnusedParameters": false,
-    "noImplicitReturns": false,
+    "strict": true,
+    "strictNullChecks": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
     "noImplicitAny": false,
-    "noImplicitThis": false,
-    "noFallthroughCasesInSwitch": false,
+    "noImplicitThis": true,
+    "noFallthroughCasesInSwitch": true,
     "declaration": true,
     "emitDecoratorMetadata": true,
     "experimentalDecorators": true,
@@ -17,8 +17,6 @@
     "preserveSymlinks": true,
     "removeComments": false,
     "isolatedModules": true,
-    "jsx": "preserve",
-    "jsxImportSource": "solid-js",
     "downlevelIteration": true,
     "lib": ["ES2019", "dom"],
     "target": "ES2018",