yoda-language-server 0.8.0 → 0.10.1

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,49 @@
+
+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: localStdout } = await asyncExec("gem list --local --exact yoda-language-server")
+    const localVersion = extractVersion(localStdout)
+
+    const { stdout: remoteStdout } = await asyncExec("gem list --remote --no-prerelease --exact yoda-language-server")
+    const remoteVersion = extractVersion(remoteStdout)
+
+    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 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 available.` : 
+    '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/cli/analyze_deps.rb

@@ -16,7 +16,7 @@ module Yoda
 
         # @param root_path [String]
         def initialize(root_path)
-          @root_path = root_path
+          @root_path = File.expand_path(root_path)
         end
 
         # @return [Array<Yoda::Store::Objects::Library::Gem>]
@@ -28,6 +28,7 @@ module Yoda
           {
             path: root_path,
             dependencies: gems.map(&:to_h),
+            autoload_dependency_ids: autoload_gem_ids,
           }
         end
 
@@ -45,39 +46,47 @@ module Yoda
           end
         end
 
-        # @return [Array<Bundler::LazySpecification>, nil]
+        # @return [Array<String>]
+        def autoload_gem_ids
+          if has_gemfile?
+            gems.map(&:id)
+          else
+            []
+          end
+        end
+
+        # @return [Array<Bundler::LazySpecification, Gem::Specification>, nil]
         def gem_specs
           @gem_specs ||= begin
-            Dir.chdir(root_path) do
-              with_unbundled_env do
-                # Suppress bundler outputs to stdout.
-                Bundler.ui = Bundler::UI::Silent.new
-
-                Bundler.reset!
-
-                if File.exists?("Gemfile")
-                  # Resolve dependencies of uninstalled gems and ensure remote sources are available.
-                  Bundler.definition.resolve_remotely!
-                  spec_set = Bundler.definition.resolve
-
-                  if Gem::Version.new(Bundler::VERSION) >= Gem::Version.new('2.2.25')
-                    deps = Bundler.definition.requested_dependencies
-                    spec_set.materialize(deps).to_a
-                  else
-                    # For backward compatibility (Ref: https://github.com/rubygems/rubygems/pull/4788)
-                    deps = Bundler.definition.send(:requested_dependencies)
-                    missing = []
-                    materialized = spec_set.materialize(deps, missing)
-                    materialized.to_a + missing
-                  end
+            with_project_env do
+              if has_gemfile?
+                # Resolve dependencies of uninstalled gems and ensure remote sources are available.
+                Bundler.definition.resolve_remotely!
+                spec_set = Bundler.definition.resolve
+
+                if Gem::Version.new(Bundler::VERSION) >= Gem::Version.new('2.2.25')
+                  deps = Bundler.definition.requested_dependencies
+                  spec_set.materialize(deps).to_a
                 else
-                  []
+                  # For backward compatibility (Ref: https://github.com/rubygems/rubygems/pull/4788)
+                  deps = Bundler.definition.send(:requested_dependencies)
+                  missing = []
+                  materialized = spec_set.materialize(deps, missing)
+
+                  materialized.to_a + missing
                 end
+              else
+                [] # Gem::Specification.latest_specs(true)
               end
             end
           end
         end
 
+        # @return [Boolean]
+        def has_gemfile?
+          File.exists?(File.expand_path("Gemfile", root_path))
+        end
+
         # @param [Gem::Specification]
         def metadata?(spec)
           spec.source.is_a?(Bundler::Source::Metadata)
@@ -88,6 +97,18 @@ module Yoda
           spec.source.is_a?(Bundler::Source::Path) && (File.expand_path(spec.source.path) == File.expand_path(root_path))
         end
 
+        def with_project_env
+          Dir.chdir(root_path) do
+            with_unbundled_env do
+              # Suppress bundler outputs to stdout.
+              Bundler.ui = Bundler::UI::Silent.new
+              Bundler.reset!
+
+              yield
+            end
+          end
+        end
+
         def with_unbundled_env(&block)
           if Bundler.respond_to?(:with_unbundled_env)
             Bundler.with_unbundled_env(&block)

data/lib/yoda/id_mask.rb

@@ -0,0 +1,84 @@
+require 'set'
+
+module Yoda
+  class IdMask
+    # @return [Hash<Symbol>, nil]
+    attr_reader :pattern
+
+    # @param pattern [IdMask, Set<Symbol>, Array<Symbol>, Hash<Symbol>, nil]
+    # @return [IdMask]
+    def self.build(pattern)
+      if pattern.is_a?(IdMask)
+        pattern
+      elsif pattern.nil?
+        new(pattern)
+      elsif pattern.is_a?(Hash)
+        new(pattern.map { |k, v| [k.to_sym, v] }.to_h)
+      else
+        new(pattern.to_a.to_h { |id| [id.to_sym, nil] })
+      end
+    end
+
+    # @param pattern [Hash<Symbol>, nil]
+    def initialize(pattern)
+      fail TypeError, "pattern must be a Hash or nil" unless pattern.is_a?(Hash) || pattern.nil?
+      @pattern = pattern
+    end
+
+    # @param id [Symbol, String]
+    # @return [Boolean]
+    def cover?(id)
+      return true if any?
+      pattern.has_key?(id.to_sym)
+    end
+
+    # @param another [IdMasklia, Set<Symbol>, Array<Symbol>, Hash<Symbol>, nil]
+    # @return [IdMask]
+    def intersection(another)
+      another_mask = IdMask.build(another)
+      return another_mask if any?
+      return self if another_mask.any?
+
+      ids_intersection = covering_ids & another_mask.covering_ids
+
+      intersection_pattern = ids_intersection.map do |id|
+        [id, nesting_mask(id) & another_mask.nesting_mask(id)]
+      end.to_h
+
+      IdMask.build(intersection_pattern)
+    end
+
+    alias_method :&, :intersection
+
+    # @return [Boolean]
+    def any?
+      pattern.nil?
+    end
+
+    # @return [Set<Symbol>, nil]
+    def covering_ids
+      @covering_ids ||= begin
+        if any?
+          nil
+        else 
+          Set.new(pattern.keys)
+        end
+      end
+    end
+
+    # @param id [String, Symbol]
+    # @return [IdMask]
+    def nesting_mask(id)
+      if pattern.is_a?(Hash)
+        IdMask.build(pattern[id.to_sym])
+      else
+        IdMask.build(nil)
+      end
+    end
+
+    # @return [Hash, nil]
+    def to_pattern
+      pattern&.map { |k, v| [k, v&.to_pattern] }&.to_h
+    end
+  end
+end

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/model/descriptions/require_path_description.rb

@@ -0,0 +1,45 @@
+module Yoda
+  module Model
+    module Descriptions
+      # @abstract
+      class RequirePathDescription
+        # @return [String]
+        attr_reader :path
+
+        # @param path [String]
+        def initialize(path)
+          @path = path
+        end
+
+        # @abstract
+        # @return [String]
+        def title
+          path
+        end
+
+        # @abstract
+        # @return [String]
+        def sort_text
+          path
+        end
+
+        # @return [String]
+        def label
+          sort_text
+        end
+
+        # @abstract
+        # @return [String]
+        def to_markdown
+          path
+        end
+
+        # Return an LSP MarkedString content for description
+        # @return [String, Hash]
+        def markup_content
+          to_markdown
+        end
+      end
+    end
+  end
+end

data/lib/yoda/model/descriptions.rb

@@ -7,6 +7,7 @@ module Yoda
       require 'yoda/model/descriptions/value_description'
       require 'yoda/model/descriptions/word_description'
       require 'yoda/model/descriptions/node_description'
+      require 'yoda/model/descriptions/require_path_description'
       require 'yoda/model/descriptions/variable_description'
     end
   end

data/lib/yoda/model/node_signatures/node.rb

@@ -3,7 +3,15 @@ module Yoda
     module NodeSignatures
       class Node < Base
         def descriptions
-          [node_type_description, *type_descriptions]
+          if node_info.require_paths.empty?
+            [node_type_description, *type_descriptions]
+          else
+            node_info.require_paths.map { |path| Descriptions::RequirePathDescription.new(path) }
+          end
+        end
+
+        def defined_files
+          node_info.require_paths.map { |path| [path, Parsing::Location.first_row, Parsing::Location.first_column] }
         end
       end
     end

data/lib/yoda/model/values/literal_value.rb

@@ -11,6 +11,9 @@ module Yoda
         # @return [Base]
         attr_reader :value
 
+        # @return [Object]
+        attr_reader :literal
+
         # @param value [Base]
         # @param literal [Object]
         def initialize(value:, literal:)

data/lib/yoda/parsing/location.rb

@@ -17,6 +17,15 @@ module Yoda
         @column = column
       end
 
+      def self.first_row
+        1
+      end
+
+      def self.first_column
+        0
+      end
+
+
       # @param ast_location [Parser::Source::Map, Parser::Source::Range]
       # @return [Location, nil]
       def self.of_ast_location(ast_location)

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