yoda-language-server 0.7.1 → 0.9.0

data/client/vscode/package.json

@@ -4,8 +4,13 @@
     "description": "Static analytics tool for Ruby",
     "version": "0.0.1",
     "publisher": "tomoasleep",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/tomoasleep/yoda"
+    },
     "engines": {
-        "vscode": "^1.23.0"
+        "vscode": "^1.52.0"
     },
     "categories": [
         "Other"
@@ -13,30 +18,50 @@
     "activationEvents": [
         "onLanguage:ruby"
     ],
-    "main": "./out/extension",
+    "main": "./out/extension.js",
     "contributes": {
-        "commands": [
-            {
-                "command": "extension.sayHello",
-                "title": "Hello World"
+        "configuration": {
+            "title": "Yoda",
+            "properties": {
+                "yoda.path": {
+                    "type": [
+                        "string",
+                        "null"
+                    ],
+                    "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."
+                }
             }
-        ]
+        }
     },
     "scripts": {
         "vscode:prepublish": "npm run compile",
         "compile": "tsc -p ./",
         "watch": "tsc -watch -p ./",
-        "postinstall": "node ./node_modules/vscode/bin/install",
-        "update-vscode": "node ./node_modules/vscode/bin/install",
-        "test": "npm run compile && node ./node_modules/vscode/bin/test"
+        "test": "npm run compile && node ./out/test/runTest.js",
+        "package": "vsce package"
     },
     "dependencies": {
-        "vscode": "^1.1.18",
-        "vscode-languageclient": "^4.1.4"
+        "semver": "^7.3.5",
+        "vscode-languageclient": "^7.0"
     },
     "devDependencies": {
-        "@types/mocha": "^5.2.0",
-        "@types/node": "^8.0.0",
-        "typescript": "^2.9.2"
+        "@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"
     }
 }

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

@@ -0,0 +1,20 @@
+import { workspace } from 'vscode'
+
+export function calcExecutionConfiguration() {
+    const yodaPathEnv = process.env.YODA_EXECUTABLE_PATH
+    const yodaPathConfiguration = workspace.getConfiguration("yoda").get("path") as (string | null);
+    const command = yodaPathEnv || yodaPathConfiguration || 'yoda'
+
+    return { command }
+}
+
+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,42 +1,27 @@
-'use strict';
+import { ExtensionContext, Disposable } from 'vscode'
+import { isCustomExecutionPathConfigured } from './config'
+import { tryInstallOrUpdate } from './install-tools'
+import { configureLanguageServer } from './language-server'
 
-import * as path from 'path';
-
-// The module 'vscode' contains the VS Code extensibility API
-// Import the module and reference it with the alias vscode in your code below
-import * as vscode from 'vscode';
-import { LanguageClient, LanguageClientOptions, ServerOptions, TransportKind } from 'vscode-languageclient';
-import { worker } from 'cluster';
-import { workspace } from 'vscode';
+let disposable: Disposable
 
 // this method is called when your extension is activated
 // your extension is activated the very first time the command is executed
-export function activate(context: vscode.ExtensionContext) {
+export async function activate(context: ExtensionContext) {
     // Use the console to output diagnostic information (console.log) and errors (console.error)
     // This line of code will only be executed once when your extension is activated
-    console.log('Congratulations, your extension "yoda" is now active!');
-
-    let execOptions = {
-        command: 'yoda',
-        args: ['server'],
-    }
+    // console.log('Congratulations, your extension "yoda" is now active!');
 
-    let serverOptions : ServerOptions = {
-        run: execOptions,
-        debug: execOptions,
+    if (!isCustomExecutionPathConfigured()) {
+        await tryInstallOrUpdate()
     }
 
-    let clientOptions : LanguageClientOptions = {
-        documentSelector: [{ scheme: 'file', language: 'ruby' }],
-        synchronize: {
-            configurationSection: 'yoda',
-            fileEvents: workspace.createFileSystemWatcher('**/.rb'),
-        }
-    }
+    const languageServer = configureLanguageServer()
 
-    let disposable = new LanguageClient('yoda', 'Yoda', serverOptions, clientOptions).start();
+    disposable = languageServer.start()
 }
 
 // this method is called when your extension is deactivated
 export function deactivate() {
+    disposable?.dispose()
 }

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

@@ -0,0 +1,109 @@
+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 { asyncExec, asyncExecPipeline } from './utils'
+
+export function isLanguageServerInstalled(): boolean {
+    const { command } =  calcExecutionConfiguration()
+    try {
+        child_process.execSync(command, { stdio: 'ignore' });
+        return true
+    } catch (e) {
+        return false
+    }
+}
+
+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:
+            break;
+    }
+}
+
+async function installTool() {
+    outputChannel.show()
+    outputChannel.clear()
+
+    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 {
+        await asyncExec("gem list --installed --exact specific_install")
+    } catch (e) {
+        outputChannel.appendLine('gem install specific_install')
+        await asyncExecPipeline("gem install specific_install", (stdout, stderr) => {
+            if (stdout) {
+                outputChannel.append(stdout)
+            }
+            if (stderr) {
+                outputChannel.append(stderr)
+            }
+        })
+        outputChannel.appendLine('')
+    }
+
+    outputChannel.appendLine('gem specific_install tomoasleep/yoda')
+    await asyncExecPipeline("gem specific_install tomoasleep/yoda", (stdout, stderr) => {
+        if (stdout) {
+            outputChannel.append(stdout)
+        }
+        if (stderr) {
+            outputChannel.append(stderr)
+        }
+    })
+}

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

@@ -0,0 +1,59 @@
+import { workspace, OutputChannel, window } from 'vscode'
+import { LanguageClient, LanguageClientOptions, ServerOptions } from 'vscode-languageclient/node'
+import { calcExecutionConfiguration, getTraceConfiguration } from './config'
+import { outputChannel } from './status'
+
+export function configureLanguageServer(): LanguageClient {
+    const { command } = calcExecutionConfiguration()
+    const yodaTraceConfiguration = getTraceConfiguration()
+
+    const isDebug = !!(process.env.YODA_DEBUG?.length)
+    const isTrace = isDebug || (yodaTraceConfiguration == "verbose")
+
+    console.log(`Use yoda at ${command}`)
+
+    const logLevelOption = isTrace ? '--log-level=trace' : '--log-level=info'
+    const serverOptions : ServerOptions = {
+        run: { command, args: ['server', logLevelOption] },
+        debug: { command, args: ['server', logLevelOption] },
+    }
+
+    const clientOptions : LanguageClientOptions = {
+        progressOnInitialization: true,
+        documentSelector: [{ scheme: 'file', language: 'ruby' }],
+        synchronize: {
+            configurationSection: 'yoda',
+            fileEvents: workspace.createFileSystemWatcher('**/.rb'),
+        },
+    }
+
+    if (isDebug) {
+        const logOutputChannel: OutputChannel = {
+            name: 'log',
+            append(value: string) {
+                outputChannel.append(value);
+                console.log(value);
+            },
+            appendLine(value: string) {
+                outputChannel.appendLine(value);
+                console.log(value);
+            },
+            replace(value: string) {
+                outputChannel.replace(value);
+                console.log(value);
+            },
+            clear() { outputChannel.clear() },
+            show() { outputChannel.show() },
+            hide() { outputChannel.hide() },
+            dispose() { outputChannel.dispose() }
+        };
+
+        clientOptions.outputChannel = logOutputChannel
+        clientOptions.traceOutputChannel = logOutputChannel
+    } else {
+        clientOptions.outputChannel = outputChannel
+    }
+
+    return new LanguageClient('yoda', 'Yoda', serverOptions, clientOptions);
+}
+

data/client/vscode/src/status.ts

@@ -0,0 +1,3 @@
+import { window } from 'vscode'
+
+export const outputChannel = window.createOutputChannel('Yoda')

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

@@ -0,0 +1,30 @@
+import * as path from 'path';
+
+import { runTests } from '@vscode/test-electron';
+
+async function main() {
+	try {
+		const packageRootPath = path.resolve(__dirname, '../../');
+
+		// The folder containing the Extension Manifest package.json
+		// Passed to `--extensionDevelopmentPath`
+		const extensionDevelopmentPath = packageRootPath;
+
+		// The path to test runner
+		// Passed to --extensionTestsPath
+		const extensionTestsPath = path.resolve(__dirname, './suite');
+
+		const extensionTestsEnv = {
+			"YODA_EXECUTABLE_PATH": path.resolve(packageRootPath, '../../exe/yoda'),
+			"YODA_DEBUG": "true",
+		}
+
+		// Download VS Code, unzip it and run the integration test
+		await runTests({ extensionDevelopmentPath, extensionTestsPath, extensionTestsEnv });
+	} catch (err) {
+		console.error('Failed to run tests');
+		process.exit(1);
+	}
+}
+
+main();

data/client/vscode/src/test/{completion.test.ts → suite/completion.test.ts}

@@ -1,6 +1,6 @@
 import * as vscode from 'vscode';
 import * as assert from 'assert';
-import { getDocUri, activate } from './helper';
+import { getDocUri, activate } from '../helper';
 
 describe('Should do completion', () => {
   const docUri = getDocUri('completion.rb');
@@ -9,6 +9,7 @@ describe('Should do completion', () => {
     await testCompletion(docUri, new vscode.Position(0, 2), {
       items: [
         { label: 'Object', kind: vscode.CompletionItemKind.Class },
+        { label: 'ObjectSpace', kind: vscode.CompletionItemKind.Module },
       ]
     });
   })

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

@@ -0,0 +1,31 @@
+import * as vscode from 'vscode';
+import { expect } from 'chai';
+import { getDocUri, activate } from '../helper';
+
+describe('Should provide hover', () => {
+  const docUri = getDocUri('completion.rb');
+
+  it('show hover', async () => {
+		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 requestComplete(
+	docUri: vscode.Uri,
+	position: vscode.Position,
+): Promise<vscode.Hover[]> {
+	const hovers = await vscode.commands.executeCommand<vscode.Hover[]>(
+		'vscode.executeHoverProvider',
+		docUri,
+		position,
+	);
+
+	return hovers
+}

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

@@ -0,0 +1,26 @@
+import * as path from 'path';
+import * as Mocha from 'mocha';
+import * as glob from 'glob';
+
+
+export function run(testsRoot: string, callback: (error: any, failures?: number) => void): void {
+  const mocha = new Mocha({
+    ui: 'bdd',
+    timeout: 600000,
+    color: true,
+  });
+
+  glob('**/**.test.js', { cwd: testsRoot }, (error, files) => {
+    if (error) {
+      return callback(error);
+    }
+
+    files.forEach(file => mocha.addFile(path.resolve(testsRoot, file)));
+
+    try {
+      mocha.run(failures => callback(null, failures))
+    } catch (error) {
+      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/client/vscode/tsconfig.json

@@ -9,8 +9,11 @@
         "sourceMap": true,
         "rootDir": "src"
     },
+    "include": [
+        "src/**/*"
+    ],
     "exclude": [
         "node_modules",
         ".vscode-test"
     ]
-}
+}

data/exe/yoda

@@ -5,4 +5,4 @@ if Dir.exist?(File.join(__dir__, "..", ".git"))
 end
 
 require 'yoda'
-Yoda::Commands::Top.start(ARGV)
+Yoda::Cli::Top.start(ARGV)

data/lib/yoda/ast/array_node.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module AST
+    class ArrayNode < Node
+      # @return [Array<Vnode>]
+      def contents
+        children
+      end
+    end
+  end
+end

data/lib/yoda/ast/assignment_node.rb

@@ -0,0 +1,15 @@
+module Yoda
+  module AST
+    class AssignmentNode < Node
+      # @return [NameVnode]
+      def assignee
+        children[0]
+      end
+
+      # @return [Node]
+      def content
+        children[1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/block_call_node.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module AST
+    class BlockCallNode < Node
+      # @return [SendNode]
+      def send_clause
+        children[0]
+      end
+
+      # @return [ParametersNode]
+      def parameters
+        children[1]
+      end
+
+      # @return [Vnode]
+      def body
+        children[2]
+      end
+    end
+  end
+end

data/lib/yoda/ast/block_node.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module AST
+    class BlockNode < Node
+      # @return [Node]
+      def content
+        children[0]
+      end
+    end
+  end
+end

data/lib/yoda/ast/case_node.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module AST
+    class CaseNode < Node
+      # @return [Node]
+      def target
+        children[0]
+      end
+
+      # @return [Array<Node>]
+      def when_clauses
+        children.slice(1..-2) || []
+      end
+
+      # @return [Node]
+      def else_clause
+        children.last
+      end
+    end
+  end
+end

data/lib/yoda/ast/center_operator_node.rb

@@ -0,0 +1,20 @@
+module Yoda
+  module AST
+    class CenterOperatorNode < Node
+      # @return [Symbol]
+      def operator
+        type
+      end
+
+      # @return [Node]
+      def left_content
+        children[0]
+      end
+
+      # @return [Node]
+      def right_content
+        children[1]
+      end
+    end
+  end
+end

data/lib/yoda/ast/class_node.rb

@@ -0,0 +1,22 @@
+module Yoda
+  module AST
+    class ClassNode < Node
+      include Namespace
+
+      # @return [ConstantNode]
+      def receiver
+        children[0]
+      end
+
+      # @return [Vnode]
+      def super_class
+        children[1]
+      end
+
+      # @return [Vnode]
+      def body
+        children[2]
+      end
+    end
+  end
+end

data/lib/yoda/ast/comment_block/base_part.rb

@@ -0,0 +1,12 @@
+require 'yoda/ast/comment_block/range_calculation'
+
+module Yoda
+  module AST
+    class CommentBlock
+      # @abstract
+      class BasePart
+        include RangeCalculation
+      end
+    end
+  end
+end