Feature: Automatically restart language client when config or rules files change (#75)

* test: prepare test fixture and activate extension only once, before all other tests

* test: added speed target of 1s for tests in general and 3s for initialization test, otherwise mocha display a lot of red text

* feat: restart language client if sgconfig.yml or a rule file changes

* fix: cleaned up 4 nits. 1) fn name 'restartOnEdits'->'watchEditsToRestartLanguageClient' to convey that it does not immediately restart. 2) unsorted package.json dependencies which were automatically sorted by npm install. 3) removed a commented console.log statement. 4) Undid accidental upgrade of prettier from 3.0.0 to 3.4.0

* fix: attempting to resolve failing windows CI test by waiting longer for initial diagnostics to match their expectations, before actually testing diagnostic changes from file modifications

Author: StevenLove

fixture/rules/README.md

@@ -0,0 +1,12 @@
+Make sure that your custom rules in this directory are properly parsed.
+`npm run test` will test the LSP which does NOT report errors with rule files (https://github.com/ast-grep/ast-grep/issues/722)
+but it will break all of the tests.
+
+You can run
+
+```bash
+cd fixture
+sg scan
+```
+
+to verify that the rules are parsed correctly.

fixture/test.ts

@@ -9,3 +9,11 @@ class AnotherCase {
     return 123
   }
 }
+
+const NoProblemHere = {
+  test() {
+    if (Math.random() > 3) {
+      throw new Error('This is not an error')
+    }
+  }
+}

package-lock.json

@@ -75,6 +75,7 @@
     "**/*": "prettier --write --ignore-unknown"
   },
   "dependencies": {
+    "js-yaml": "^4.1.0",
     "vscode-languageclient": "^9.0.0"
   },
   "devDependencies": {
@@ -96,6 +97,7 @@
     "@types/react": "18.2.51",
     "@types/react-dom": "18.2.18",
     "@types/glob": "^8.0.0",
+    "@types/js-yaml": "^4.0.9",
     "@types/mocha": "^10.0.0",
     "@types/node": "^20.0.0",
     "@types/vscode": "^1.73.0",

package.json

@@ -7,16 +7,33 @@ async function run() {
   // Create the mocha test
   const mocha = new Mocha({
     ui: 'tdd',
-    color: true
+    color: true,
+    timeout: 100000,
+    slow: 1000
   })
-  mocha.timeout(100000)
 
-  const testsRoot = path.join(__dirname, '../../src/test')
+  /**
+    Before any other tests, run the testSetup.ts file 
+    This will set up the test environment necessary for the other tests to run
+  */
+  mocha.addFile(path.join(__dirname, 'testSetup.ts'))
 
+  /**
+   * Add each test file in src/test/**.test.ts to the test suite
+   * Tests are run in series and should be designed to not have side effects
+   * But side effects are possible and therefore test order could matter
+   * So you could play with sort order on the tests to investigate
+   */
   try {
+    const testsRoot = path.join(__dirname, '../../src/test')
     let files = await glob('**.test.ts', { cwd: testsRoot })
     // Add files to the test suite
-    files.forEach(f => mocha.addFile(path.resolve(testsRoot, f)))
+    files.sort((a, b) => {
+      return a.localeCompare(b)
+    })
+    files.forEach(f => {
+      mocha.addFile(path.resolve(testsRoot, f))
+    })
 
     return new Promise((resolve, reject) => {
       // Run the mocha test

scripts/test/integration-test.cjs

@@ -0,0 +1,12 @@
+import { activate } from '../../src/test/utils'
+/**
+ * This initialization runs once, before the rest of the tests.
+ * It is used to open the test fixture folder and activate the extension.
+ * We could add some asserts here to make sure the environment looks as expected.
+ */
+
+suite('Initializing', () => {
+  test('Initialize', async () => {
+    await activate()
+  }).slow(3000) // This test is slow because it waits for the server to start. And it specifically waits for 2 seconds.
+})

scripts/test/testSetup.ts

@@ -11,15 +11,21 @@ import {
   Position,
   TextDocumentShowOptions,
   TextDocument,
+  Disposable,
   Uri,
-  ThemeIcon
+  ThemeIcon,
+  FileSystemWatcher,
+  RelativePattern
 } from 'vscode'
 
+import * as yaml from 'js-yaml'
+import path from 'path'
 import {
   LanguageClient,
   LanguageClientOptions,
   ServerOptions,
-  Executable
+  Executable,
+  State
 } from 'vscode-languageclient/node'
 
 import { activate as activateWebview } from './view'
@@ -232,11 +238,99 @@ function activateLsp(context: ExtensionContext) {
   client.start()
 }
 
+async function watchEditsToRestartLanguageClient(context: ExtensionContext) {
+  // TODO: handle case where sgconfig.yml is not in root
+  // TODO: handle case where configPath is not set to sgconfig.yml
+  // TODO: handle case where no workspace folder is open and then we open one
+  // TODO: make sure dispose actually does what it should do
+  // TODO: handle more than 1 element in ruleDirs
+
+  if (!workspace.workspaceFolders || !workspace.workspaceFolders[0]) {
+    return
+  }
+
+  let ruleWatcher: FileSystemWatcher | undefined
+  let disposables: Disposable[] = []
+  async function getRuleDirs(configPath: string): Promise<string[]> {
+    try {
+      // get the absolute URI to this relative path
+      let configUri = Uri.file(
+        workspace.workspaceFolders![0].uri.fsPath + '/' + configPath
+      )
+      // read the config file
+      let configText = await workspace.fs.readFile(configUri)
+      // parse the config file
+      let config = yaml.load(configText.toString()) as { ruleDirs: string[] }
+      // get the rules dir
+      let ruleDirs = config['ruleDirs']
+      return ruleDirs
+    } catch (e) {
+      console.error('Error parsing config file to find ruleDirs', e)
+      return ['rules']
+    }
+  }
+  async function updateRuleDirsWatcher() {
+    /* Assume that we have an open workspace folder, otherwise we won't be able to run anyway */
+    if (!workspace.workspaceFolders || !workspace.workspaceFolders[0]) {
+      return
+    }
+    let ruleDirsPath = await getRuleDirs('sgconfig.yml')
+    if (ruleWatcher !== undefined) {
+      let idx = context.subscriptions.findIndex(item => item === ruleWatcher)
+      context.subscriptions.splice(idx, 1)
+      disposables.forEach(item => item.dispose())
+      disposables = []
+    }
+    let rel = path.join(ruleDirsPath[0], '*.yml')
+    ruleWatcher = workspace.createFileSystemWatcher(
+      new RelativePattern(workspace.workspaceFolders[0].uri.fsPath, rel)
+    )
+    disposables = [
+      ruleWatcher.onDidChange(uri => {
+        console.log(`File changed: ${uri.fsPath}`)
+        restart()
+      }),
+      ruleWatcher.onDidCreate(uri => {
+        console.log(`File created: ${uri.fsPath}`)
+        restart()
+      }),
+      ruleWatcher.onDidDelete(uri => {
+        console.log(`File deleted: ${uri.fsPath}`)
+        restart()
+      })
+    ]
+    disposables.push(ruleWatcher)
+    context.subscriptions.push(ruleWatcher)
+  }
+
+  const configFileWatcher = workspace.createFileSystemWatcher(
+    new RelativePattern(
+      workspace.workspaceFolders[0].uri.fsPath,
+      'sgconfig.yml'
+    )
+  )
+
+  configFileWatcher.onDidChange(uri => {
+    console.log(`File changed: ${uri.fsPath}`)
+    updateRuleDirsWatcher()
+    restart()
+  })
+
+  context.subscriptions.push(configFileWatcher)
+  updateRuleDirsWatcher()
+}
+
 export function activate(context: ExtensionContext) {
+  watchEditsToRestartLanguageClient(context)
   activateLsp(context)
   activateWebview(context)
 }
 
+async function restart() {
+  await deactivate()
+  return await client.start()
+}
+
 workspace.onDidChangeConfiguration(changeEvent => {
   if (changeEvent.affectsConfiguration('astGrep')) {
     deactivate()

src/extension.ts

@@ -1,7 +1,7 @@
 import * as vscode from 'vscode'
 import * as assert from 'assert'
 
-import { getDocUri, activate } from './utils'
+import { getDocUri } from './utils'
 
 suite('Should get code action', () => {
   const docUri = getDocUri('test.ts')
@@ -37,8 +37,6 @@ async function testCodeFix(
   range: vscode.Range,
   expectedCodeActions: vscode.CodeAction[]
 ) {
-  await activate(docUri)
-
   const actualCodeActions = (await vscode.commands.executeCommand(
     'vscode.executeCodeActionProvider',
     docUri,

src/test/codefix.test.ts

@@ -1,7 +1,7 @@
 import * as vscode from 'vscode'
 import * as assert from 'assert'
 
-import { getDocUri, activate } from './utils'
+import { getDocUri } from './utils'
 
 suite('Should get diagnostics', () => {
   const docUri = getDocUri('test.ts')
@@ -39,8 +39,6 @@ async function testDiagnostics(
   docUri: vscode.Uri,
   expectedDiagnostics: vscode.Diagnostic[]
 ) {
-  await activate(docUri)
-
   const actualDiagnostics = vscode.languages.getDiagnostics(docUri)
   actualDiagnostics.sort((a, b) =>
     a.message === b.message ? 0 : a.message > b.message ? 1 : -1