yoda-language-server 0.8.0 → 0.9.0

data/client/vscode/package.json

@@ -30,6 +30,12 @@
                     ],
                     "default": null,
                     "description": "Specifies the path of yoda."
+                },
+                "yoda.trace.server": {
+                    "type": "string",
+                    "enum": ["off", "messages", "compact", "verbose"],
+                    "default": "off",
+                    "description": "Message level of yoda server."
                 }
             }
         }
@@ -42,16 +48,20 @@
         "package": "vsce package"
     },
     "dependencies": {
+        "semver": "^7.3.5",
         "vscode-languageclient": "^7.0"
     },
     "devDependencies": {
-        "@types/mocha": "^5.2.6",
-        "@types/node": "^8.10.66",
-        "@types/vscode": "^1.52.0",
-        "glob": "^7.1.4",
-        "mocha": "^9.1.3",
+        "@types/chai": "^4.3",
+        "@types/mocha": "^9.1",
+        "@types/node": "^8.10",
+        "@types/semver": "^7.3.9",
+        "@types/vscode": "^1.52",
+        "@vscode/test-electron": "^2.1",
+        "chai": "^4.3",
+        "glob": "^7.1",
+        "mocha": "^9.1",
         "typescript": "^4",
-        "vsce": "^2.6.0",
-        "vscode-test": "^1.5"
+        "vsce": "^2.6.0"
     }
 }

data/client/vscode/src/check-versions.ts

@@ -0,0 +1,55 @@
+
+import { execSync } from 'child_process'
+import { cmp, maxSatisfying } from 'semver'
+import { asyncExec } from './utils'
+
+interface CheckResult {
+    shouldUpdate: boolean
+    localVersion: string
+    remoteVersion: string
+}
+
+export async function checkVersions(): Promise<CheckResult> {
+    const { stdout } = await asyncExec("gem list --both --exact yoda-language-server")
+    const [localVersion, remoteVersion] = parseGemList(stdout)
+
+    return {
+        shouldUpdate: shouldUpdate(localVersion, remoteVersion),
+        localVersion: localVersion,
+        remoteVersion: remoteVersion,
+    }
+}
+
+function shouldUpdate(localVersion: string, remoteVersion: string): boolean {
+    if (!localVersion) {
+        return true
+    }
+
+    if (!remoteVersion) {
+        return false
+    }
+
+    return cmp(localVersion, "<", remoteVersion)
+}
+
+function parseGemList(stdout: string): [string, string] {
+    const [local, remote] = stdout.split("*** REMOTE GEMS ***")
+
+    const localVersion = extractVersion(local)
+    const remoteVersion = extractVersion(remote)
+
+    return [localVersion, remoteVersion]
+}
+
+function extractVersion(text: string): string {
+    const lines = text.split("\n")
+    for (const line of lines) {
+        const matchData = line.match(/^yoda-language-server\s*\((.+)\)/);
+        if (matchData) {
+            const versions = matchData[1].split(/,\s*/)
+            return maxSatisfying(versions, '*')
+        }
+    }
+
+    return null
+}

data/client/vscode/src/config.ts

@@ -8,6 +8,13 @@ export function calcExecutionConfiguration() {
     return { command }
 }
 
-export function getTraceConfiguration (): string | null {
+export function isCustomExecutionPathConfigured(): boolean {
+    const yodaPathEnv = process.env.YODA_EXECUTABLE_PATH
+    const yodaPathConfiguration = workspace.getConfiguration("yoda").get("path") as (string | null);
+
+    return !!(yodaPathEnv || yodaPathConfiguration)
+}
+
+export function getTraceConfiguration(): string | null {
   return workspace.getConfiguration("yoda").get("trace.server") as (string | null);
 }

data/client/vscode/src/extension.ts

@@ -1,5 +1,6 @@
 import { ExtensionContext, Disposable } from 'vscode'
-import { isLanguageServerInstalled, promptForInstallTool } from './install-tools'
+import { isCustomExecutionPathConfigured } from './config'
+import { tryInstallOrUpdate } from './install-tools'
 import { configureLanguageServer } from './language-server'
 
 let disposable: Disposable
@@ -11,8 +12,8 @@ export async function activate(context: ExtensionContext) {
     // This line of code will only be executed once when your extension is activated
     // console.log('Congratulations, your extension "yoda" is now active!');
 
-    if (!isLanguageServerInstalled()) {
-        await promptForInstallTool()
+    if (!isCustomExecutionPathConfigured()) {
+        await tryInstallOrUpdate()
     }
 
     const languageServer = configureLanguageServer()

data/client/vscode/src/install-tools.ts

@@ -1,17 +1,10 @@
 import * as child_process from 'child_process'
 
 import { window } from 'vscode'
+import { checkVersions } from './check-versions'
 import { calcExecutionConfiguration, getTraceConfiguration } from './config'
 import { outputChannel } from './status'
-import { promisify } from 'util'
-
-function execCommand(command: string, onMessage: (stdout: string | null, stderr: string | null) => void, callback: (error: Error) => void) {
-    const process = child_process.exec(command, callback)
-    process.stdout.on('data', (data) => onMessage(data.toString(), null))
-    process.stderr.on('data', (data) => onMessage(null, data.toString()))
-}
-
-const asyncExecCommand = promisify(execCommand)
+import { asyncExec, asyncExecPipeline } from './utils'
 
 export function isLanguageServerInstalled(): boolean {
     const { command } =  calcExecutionConfiguration()
@@ -23,11 +16,41 @@ export function isLanguageServerInstalled(): boolean {
     }
 }
 
-export async function promptForInstallTool() {
-    const choises = ['Install']
-    const selected = await window.showInformationMessage('yoda command is not available. Please install.', ...choises)
+export async function tryInstallOrUpdate() {
+    try {
+        if (!isLanguageServerInstalled()) {
+            outputChannel.appendLine(`Yoda is not installed. Ask to install.`)
+            await promptForInstallTool(false)
+            return
+        }
+
+        const { shouldUpdate, localVersion, remoteVersion } = await checkVersions()
+
+        console.log(`Local version: ${localVersion}`)
+        console.log(`Available version: ${remoteVersion}`)
+        console.log(`shouldUpdate: ${shouldUpdate}`)
+
+        if (shouldUpdate) {
+            await promptForInstallTool(localVersion !== null, remoteVersion)
+        }
+    } catch (e) {
+        outputChannel.appendLine(`An error occured on update: ${e}`)
+    }
+}
+
+export async function promptForInstallTool(update: boolean, newVersion?: string) {
+    const choises = [update ? 'Update' : 'Install']
+
+    const newVersionLabel = newVersion ? ` (${newVersion})` : ''
+
+    const message = update ? 
+    `A newer version of yoda${newVersionLabel} is updatable.` : 
+    'yoda command is not available. Please install.'
+
+    const selected = await window.showInformationMessage(message, ...choises)
     switch (selected) {
         case 'Install':
+        case 'Update':
             await installTool()
             break;
         default:
@@ -41,11 +64,29 @@ async function installTool() {
 
     outputChannel.appendLine('Installing yoda...')
 
+    await installGemFromRubygems()
+
+    outputChannel.appendLine('yoda is installed.')
+}
+
+async function installGemFromRubygems() {
+    outputChannel.appendLine('gem install yoda-language-server')
+    await asyncExecPipeline("yes | gem install yoda-language-server", (stdout, stderr) => {
+        if (stdout) {
+            outputChannel.append(stdout)
+        }
+        if (stderr) {
+            outputChannel.append(stderr)
+        }
+    })
+}
+
+async function installGemFromRepository() {
     try {
-        child_process.execSync("gem list --installed --exact specific_install")
+        await asyncExec("gem list --installed --exact specific_install")
     } catch (e) {
         outputChannel.appendLine('gem install specific_install')
-        await asyncExecCommand("gem install specific_install", (stdout, stderr) => {
+        await asyncExecPipeline("gem install specific_install", (stdout, stderr) => {
             if (stdout) {
                 outputChannel.append(stdout)
             }
@@ -57,7 +98,7 @@ async function installTool() {
     }
 
     outputChannel.appendLine('gem specific_install tomoasleep/yoda')
-    await asyncExecCommand("gem specific_install tomoasleep/yoda", (stdout, stderr) => {
+    await asyncExecPipeline("gem specific_install tomoasleep/yoda", (stdout, stderr) => {
         if (stdout) {
             outputChannel.append(stdout)
         }
@@ -65,5 +106,4 @@ async function installTool() {
             outputChannel.append(stderr)
         }
     })
-    outputChannel.appendLine('yoda is installed.')
 }

data/client/vscode/src/language-server.ts

@@ -19,6 +19,7 @@ export function configureLanguageServer(): LanguageClient {
     }
 
     const clientOptions : LanguageClientOptions = {
+        progressOnInitialization: true,
         documentSelector: [{ scheme: 'file', language: 'ruby' }],
         synchronize: {
             configurationSection: 'yoda',
@@ -37,6 +38,10 @@ export function configureLanguageServer(): LanguageClient {
                 outputChannel.appendLine(value);
                 console.log(value);
             },
+            replace(value: string) {
+                outputChannel.replace(value);
+                console.log(value);
+            },
             clear() { outputChannel.clear() },
             show() { outputChannel.show() },
             hide() { outputChannel.hide() },

data/client/vscode/src/test/runTest.ts

@@ -1,6 +1,6 @@
 import * as path from 'path';
 
-import { runTests } from 'vscode-test';
+import { runTests } from '@vscode/test-electron';
 
 async function main() {
 	try {

data/client/vscode/src/test/suite/hover.test.ts

@@ -1,43 +1,31 @@
 import * as vscode from 'vscode';
-import * as assert from 'assert';
+import { expect } from 'chai';
 import { getDocUri, activate } from '../helper';
 
 describe('Should provide hover', () => {
   const docUri = getDocUri('completion.rb');
 
   it('show hover', async () => {
-    await testCompletion(docUri, new vscode.Position(0, 2), {
-      contents: [
-				{"language":"ruby","value":"Object # Object.module"},
-				"**Object.class**\n\n\n",
-			],
-			range: new vscode.Range(
-				new vscode.Position(0, 0),
-				new vscode.Position(0, 6),
-			),
-    });
-  })
+		await activate(docUri);
+
+		const actualHovers = await requestComplete(docUri, new vscode.Position(0, 2));
 
+		console.log("hovers: ", actualHovers);
 
+		expect((actualHovers[0].contents[0] as vscode.MarkdownString).value).to.include("Object # singleton(::Object)");
+		expect((actualHovers[0].contents[1] as vscode.MarkdownString).value).to.include("**Object**")
+  })
 });
 
-async function testCompletion(
+async function requestComplete(
 	docUri: vscode.Uri,
 	position: vscode.Position,
-	expectedHover: vscode.Hover
-) {
-	await activate(docUri);
-
-	// Executing the command `vscode.executeCompletionItemProvider` to simulate triggering completion
-	// See: https://code.visualstudio.com/api/references/commands
-	const [actualHover] = await vscode.commands.executeCommand<vscode.Hover[]>(
+): Promise<vscode.Hover[]> {
+	const hovers = await vscode.commands.executeCommand<vscode.Hover[]>(
 		'vscode.executeHoverProvider',
 		docUri,
-		position
+		position,
 	);
 
-	// assert.equal(actualHover.range, expectedHover.range);
-	expectedHover.contents.forEach((expectedItem, i) => {
-		assert.equal(actualHover.contents[i], expectedItem);
-	});
+	return hovers
 }

data/client/vscode/src/test/suite/index.ts

@@ -7,10 +7,9 @@ export function run(testsRoot: string, callback: (error: any, failures?: number)
   const mocha = new Mocha({
     ui: 'bdd',
     timeout: 600000,
+    color: true,
   });
 
-  mocha.useColors(true);
-
   glob('**/**.test.js', { cwd: testsRoot }, (error, files) => {
     if (error) {
       return callback(error);

data/client/vscode/src/utils.ts

@@ -0,0 +1,11 @@
+import { exec } from 'child_process'
+import { promisify } from 'util'
+
+function execPipeline(command: string, onMessage: (stdout: string | null, stderr: string | null) => void, callback: (error: Error) => void) {
+    const process = exec(command, callback)
+    process.stdout.on('data', (data) => onMessage(data.toString(), null))
+    process.stderr.on('data', (data) => onMessage(null, data.toString()))
+}
+
+export const asyncExecPipeline = promisify(execPipeline)
+export const asyncExec = promisify(exec)

data/lib/yoda/instrument.rb

@@ -130,5 +130,12 @@ module Yoda
     def registry_dump(index: nil, length: nil)
       emit(:registry_dump, index: index, length: length)
     end
+
+    # @param name [String]
+    # @param version [String]
+    # @param message [String]
+    def build_library_registry(message:, name:, version:)
+      emit(:build_library_registry, name: name, version: version, message: message)
+    end
   end
 end

data/lib/yoda/server/concurrent_writer.rb

@@ -2,7 +2,7 @@ module Yoda
   class Server
     # Wrapper class for writer to make thread safe
     class ConcurrentWriter
-      # @param [::LanguageServer::Protocol::Transport::Stdio::Writer]
+      # @param channel [::LanguageServer::Protocol::Transport::Stdio::Writer]
       def initialize(channel)
         @channel = channel
         @mutex = Mutex.new

data/lib/yoda/server/lifecycle_handler.rb

@@ -1,9 +1,12 @@
 require 'concurrent'
+require 'yoda/server/providers'
 
 module Yoda
   class Server
     # Handle
     class LifecycleHandler
+      include Providers::ReportableProgress
+
       # @return [Session, nil]
       attr_reader :session
 
@@ -41,83 +44,92 @@ module Yoda
 
       # @param params [LanguageServer::Protocol::Interface::InitializeParams]
       def handle_initialize(params)
-        Instrument.instance.hear(initialization_progress: method(:notify_initialization_progress)) do
-          @session = begin
-            if params[:workspace_folders]
-              workspace_folders = params[:workspace_folders].map { |hash| LanguageServer::Protocol::Interface::WorkspaceFolder.new(name: hash[:name], uri: hash[:uri]) }
-              Session.from_workspace_folders(workspace_folders)
-            elsif params[:root_uri]
-              Session.from_root_uri(params[:root_uri])
-            else
-              Session.new(workspaces: [])
+        in_progress(params, title: "Initializing Yoda") do |progress_reporter|
+          reporter = InitializationProgressReporter.new(progress_reporter)
+
+          subscriptions = {
+            initialization_progress: reporter.public_method(:notify_initialization_progress),
+            build_library_registry: reporter.public_method(:notify_build_library_registry),
+          }
+
+          Instrument.instance.hear(**subscriptions) do
+            @session = begin
+              if params[:workspace_folders]
+                workspace_folders = params[:workspace_folders].map { |hash| LanguageServer::Protocol::Interface::WorkspaceFolder.new(name: hash[:name], uri: hash[:uri]) }
+                Session.from_workspace_folders(workspace_folders)
+              elsif params[:root_uri]
+                Session.from_root_uri(params[:root_uri])
+              else
+                Session.new(workspaces: [])
+              end
             end
-          end
 
-          send_warnings(@session.setup || [])
+            send_warnings(@session.setup || [])
+          end
+        end
 
-          LanguageServer::Protocol::Interface::InitializeResult.new(
-            server_info: {
-              name: "yoda",
-              version: Yoda::VERSION,
-            },
-            capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
-              text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
-                open_close: true,
-                change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
-                save: LanguageServer::Protocol::Interface::SaveOptions.new(
-                  include_text: true,
-                ),
-              ),
-              completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
-                resolve_provider: false,
-                trigger_characters: ['.', '@', '[', ':', '!', '<'],
+        LanguageServer::Protocol::Interface::InitializeResult.new(
+          server_info: {
+            name: "yoda",
+            version: Yoda::VERSION,
+          },
+          capabilities: LanguageServer::Protocol::Interface::ServerCapabilities.new(
+            text_document_sync: LanguageServer::Protocol::Interface::TextDocumentSyncOptions.new(
+              open_close: true,
+              change: LanguageServer::Protocol::Constant::TextDocumentSyncKind::FULL,
+              save: LanguageServer::Protocol::Interface::SaveOptions.new(
+                include_text: true,
               ),
-              hover_provider: true,
-              definition_provider: true,
-              signature_help_provider: LanguageServer::Protocol::Interface::SignatureHelpOptions.new(
-                trigger_characters: ['(', ','],
-              ),
-              workspace_symbol_provider: LanguageServer::Protocol::Interface::WorkspaceSymbolOptions.new(
-                work_done_progress: true,
+            ),
+            completion_provider: LanguageServer::Protocol::Interface::CompletionOptions.new(
+              resolve_provider: false,
+              trigger_characters: ['.', '@', '[', ':', '!', '<'],
+            ),
+            hover_provider: true,
+            definition_provider: true,
+            signature_help_provider: LanguageServer::Protocol::Interface::SignatureHelpOptions.new(
+              trigger_characters: ['(', ','],
+            ),
+            workspace_symbol_provider: LanguageServer::Protocol::Interface::WorkspaceSymbolOptions.new(
+              work_done_progress: true,
+            ),
+            workspace: {
+              workspaceFolders: LanguageServer::Protocol::Interface::WorkspaceFoldersServerCapabilities.new(
+                supported: true,
+                change_notifications: true,
               ),
-              workspace: {
-                workspaceFolders: LanguageServer::Protocol::Interface::WorkspaceFoldersServerCapabilities.new(
-                  supported: true,
-                  change_notifications: true,
-                ),
-                fileOperations: {
-                  didCreate: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
-                    filters: [
-                      LanguageServer::Protocol::Interface::FileOperationFilter.new(
-                        pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
-                          glob: "**/*",
-                        ),
+              fileOperations: {
+                didCreate: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                  filters: [
+                    LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                      pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                        glob: "**/*",
                       ),
-                    ],
-                  ),
-                  didRename: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
-                    filters: [
-                      LanguageServer::Protocol::Interface::FileOperationFilter.new(
-                        pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
-                          glob: "**/*",
-                        ),
+                    ),
+                  ],
+                ),
+                didRename: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                  filters: [
+                    LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                      pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                        glob: "**/*",
                       ),
-                    ],
-                  ),
-                  didDelete: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
-                    filters: [
-                      LanguageServer::Protocol::Interface::FileOperationFilter.new(
-                        pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
-                          glob: "**/*",
-                        ),
+                    ),
+                  ],
+                ),
+                didDelete: LanguageServer::Protocol::Interface::FileOperationRegistrationOptions.new(
+                  filters: [
+                    LanguageServer::Protocol::Interface::FileOperationFilter.new(
+                      pattern: LanguageServer::Protocol::Interface::FileOperationPattern.new(
+                        glob: "**/*",
                       ),
-                    ],
-                  ),
-                },
+                    ),
+                  ],
+                ),
               },
-            ),
-          )
-        end
+            },
+          ),
+        )
       rescue => e
         Logger.warn e.full_message
         LanguageServer::Protocol::Interface::ResponseError.new(
@@ -206,18 +218,29 @@ module Yoda
         EOS
       end
 
-      def notify_initialization_progress(phase: nil, message: nil, index:, length:)
-        if length && length > 0
-          percentage = (index || 0) * 100 / length
-          if index <= 0
-            notifier.start_progress(id: phase, title: phase, message: message, percentage: percentage)
-          elsif index >= length
-            notifier.done_progress(id: phase)
+      class InitializationProgressReporter
+        # @return [Providers::ReportableProgress::ProgressReporter]
+        attr_reader :progress_reporter
+
+        # @param progress_reporter [Providers::ReportableProgress::ProgressReporter]
+        def initialize(progress_reporter)
+          @progress_reporter = progress_reporter
+        end
+
+        def notify_initialization_progress(phase: nil, message: nil, index:, length:)
+          if length && length > 0
+            percentage = (index || 0) * 100 / length
+
+            progress_reporter.report(message: message, percentage: percentage)
           else
-            notifier.report_progress(id: phase, message: message, percentage: percentage)
+            progress_reporter.report(message: message)
           end
-        else
-          notifier.event(type: :initialization, phase: phase, message: message)
+
+          progress_reporter.notifier.event(type: :initialization, phase: phase, message: message)
+        end
+
+        def notify_build_library_registry(message: nil, name: nil, version: nil)
+          progress_reporter.report(message: message)
         end
       end
     end