yoda-language-server 0.7.2 → 0.8.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,40 @@
     "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."
+                }
             }
-        ]
+        }
     },
     "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"
+        "vscode-languageclient": "^7.0"
     },
     "devDependencies": {
-        "@types/mocha": "^5.2.0",
-        "@types/node": "^8.0.0",
-        "typescript": "^2.9.2"
+        "@types/mocha": "^5.2.6",
+        "@types/node": "^8.10.66",
+        "@types/vscode": "^1.52.0",
+        "glob": "^7.1.4",
+        "mocha": "^9.1.3",
+        "typescript": "^4",
+        "vsce": "^2.6.0",
+        "vscode-test": "^1.5"
     }
 }

data/client/vscode/src/config.ts

@@ -0,0 +1,13 @@
+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 getTraceConfiguration (): string | null {
+  return workspace.getConfiguration("yoda").get("trace.server") as (string | null);
+}

data/client/vscode/src/extension.ts

@@ -1,42 +1,26 @@
-'use strict';
+import { ExtensionContext, Disposable } from 'vscode'
+import { isLanguageServerInstalled, promptForInstallTool } 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 (!isLanguageServerInstalled()) {
+        await promptForInstallTool()
     }
 
-    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,69 @@
+import * as child_process from 'child_process'
+
+import { window } from 'vscode'
+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)
+
+export function isLanguageServerInstalled(): boolean {
+    const { command } =  calcExecutionConfiguration()
+    try {
+        child_process.execSync(command, { stdio: 'ignore' });
+        return true
+    } catch (e) {
+        return false
+    }
+}
+
+export async function promptForInstallTool() {
+    const choises = ['Install']
+    const selected = await window.showInformationMessage('yoda command is not available. Please install.', ...choises)
+    switch (selected) {
+        case 'Install':
+            await installTool()
+            break;
+        default:
+            break;
+    }
+}
+
+async function installTool() {
+    outputChannel.show()
+    outputChannel.clear()
+
+    outputChannel.appendLine('Installing yoda...')
+
+    try {
+        child_process.execSync("gem list --installed --exact specific_install")
+    } catch (e) {
+        outputChannel.appendLine('gem install specific_install')
+        await asyncExecCommand("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 asyncExecCommand("gem specific_install tomoasleep/yoda", (stdout, stderr) => {
+        if (stdout) {
+            outputChannel.append(stdout)
+        }
+        if (stderr) {
+            outputChannel.append(stderr)
+        }
+    })
+    outputChannel.appendLine('yoda is installed.')
+}

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

@@ -0,0 +1,54 @@
+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 = {
+        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);
+            },
+            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';
+
+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,43 @@
+import * as vscode from 'vscode';
+import * as assert from 'assert';
+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),
+			),
+    });
+  })
+
+
+});
+
+async function testCompletion(
+	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[]>(
+		'vscode.executeHoverProvider',
+		docUri,
+		position
+	);
+
+	// assert.equal(actualHover.range, expectedHover.range);
+	expectedHover.contents.forEach((expectedItem, i) => {
+		assert.equal(actualHover.contents[i], expectedItem);
+	});
+}

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

@@ -0,0 +1,27 @@
+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,
+  });
+
+  mocha.useColors(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/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

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

@@ -0,0 +1,58 @@
+module Yoda
+  module AST
+    class CommentBlock
+      # @abstract
+      module RangeCalculation
+        # @!method comment_block
+        #   @abstract
+        #   @return [CommentBlock]
+
+        # @abstract
+        # @return [Integer]
+        def begin_index
+          fail NotImplementedError
+        end
+
+        # @abstract
+        # @return [Integer]
+        def end_index
+          fail NotImplementedError
+        end
+
+        # @return [Parsing::Location, nil]
+        def begin_location
+          @begin_location ||= comment_block.location_from_index(begin_index)
+        end
+
+        # @return [Parsing::Location, nil]
+        def end_location
+          @end_location ||= comment_block.location_from_index(end_index)
+        end
+
+        # @return [Parsing::Range, nil]
+        def range
+          if begin_location && end_location
+            Parsing::Range.new(begin_location, end_location)
+          else
+            nil
+          end
+        end
+
+        # @return [String, nil]
+        def text
+          if begin_location && end_location
+            comment_block.text.slice(Range.new(begin_index, end_index))
+          else
+            nil
+          end
+        end
+
+        # @param location [Parsing::Location]
+        # @return [Boolean]
+        def include?(location)
+          range&.include?(location)
+        end
+      end
+    end
+  end
+end