yoda-language-server 0.4.0 → 0.5.0

data/client/vscode/package.json

@@ -3,9 +3,9 @@
     "displayName": "yoda",
     "description": "Static analytics tool for Ruby",
     "version": "0.0.1",
-    "publisher": "nemunemu",
+    "publisher": "tomoasleep",
     "engines": {
-        "vscode": "^1.19.0"
+        "vscode": "^1.23.0"
     },
     "categories": [
         "Other"
@@ -27,13 +27,16 @@
         "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"
     },
+    "dependencies": {
+        "vscode": "^1.1.18",
+        "vscode-languageclient": "^4.1.4"
+    },
     "devDependencies": {
-        "typescript": "^2.6.1",
-        "vscode": "^1.1.6",
-        "vscode-languageclient": "^3.5.0",
-        "@types/node": "^7.0.43",
-        "@types/mocha": "^2.2.42"
+        "@types/mocha": "^5.2.0",
+        "@types/node": "^8.0.0",
+        "typescript": "^2.9.2"
     }
 }

data/client/vscode/src/extension.ts

@@ -17,7 +17,7 @@ export function activate(context: vscode.ExtensionContext) {
     console.log('Congratulations, your extension "yoda" is now active!');
 
     let execOptions = {
-        command: path.resolve(__dirname, '../../../exe/yoda'),
+        command: 'yoda',
         args: ['server'],
     }
 
@@ -34,9 +34,9 @@ export function activate(context: vscode.ExtensionContext) {
         }
     }
 
-    let disposable = new LanguageClient('yoda', 'Yoda Language Server', serverOptions, clientOptions).start();
+    let disposable = new LanguageClient('yoda', 'Yoda', serverOptions, clientOptions).start();
 }
 
 // this method is called when your extension is deactivated
 export function deactivate() {
-}
+}

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

@@ -0,0 +1,39 @@
+import * as vscode from 'vscode';
+import * as assert from 'assert';
+import { getDocUri, activate } from './helper';
+
+describe('Should do completion', () => {
+  const docUri = getDocUri('completion.rb');
+
+  it('Completes', async () => {
+    await testCompletion(docUri, new vscode.Position(0, 2), {
+      items: [
+        { label: 'Object', kind: vscode.CompletionItemKind.Class },
+      ]
+    });
+  })
+
+
+});
+
+async function testCompletion(
+	docUri: vscode.Uri,
+	position: vscode.Position,
+	expectedCompletionList: vscode.CompletionList
+) {
+	await activate(docUri);
+
+	// Executing the command `vscode.executeCompletionItemProvider` to simulate triggering completion
+	const actualCompletionList = (await vscode.commands.executeCommand(
+		'vscode.executeCompletionItemProvider',
+		docUri,
+		position
+	)) as vscode.CompletionList;
+
+	assert.equal(actualCompletionList.items.length, expectedCompletionList.items.length);
+	expectedCompletionList.items.forEach((expectedItem, i) => {
+		const actualItem = actualCompletionList.items[i];
+		assert.equal(actualItem.label, expectedItem.label);
+		assert.equal(actualItem.kind, expectedItem.kind);
+	});
+}

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

@@ -0,0 +1,38 @@
+import * as vscode from 'vscode';
+import * as path from 'path';
+
+export let doc: vscode.TextDocument;
+export let editor: vscode.TextEditor;
+export let documentEol: string;
+export let platformEol: string;
+
+export async function activate(docUri: vscode.Uri) {
+	const ext = vscode.extensions.getExtension('tomoasleep.yoda');
+	await ext.activate();
+	try {
+		doc = await vscode.workspace.openTextDocument(docUri);
+		editor = await vscode.window.showTextDocument(doc);
+		await sleep(20000); // Wait for server activation
+	} catch (e) {
+		console.error(e);
+	}
+}
+
+async function sleep(ms: number) {
+	return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+export const getDocPath = (p: string) => {
+	return path.resolve(__dirname, '../../testFixture', p);
+};
+export const getDocUri = (p: string) => {
+	return vscode.Uri.file(getDocPath(p));
+};
+
+export async function setTestContent(content: string): Promise<boolean> {
+	const all = new vscode.Range(
+		doc.positionAt(0),
+		doc.positionAt(doc.getText().length)
+	);
+	return editor.edit(eb => eb.replace(all, content));
+}

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

@@ -15,8 +15,10 @@ import * as testRunner from 'vscode/lib/testrunner';
 // You can directly control Mocha options by uncommenting the following lines
 // See https://github.com/mochajs/mocha/wiki/Using-mocha-programmatically#set-options for more info
 testRunner.configure({
-    ui: 'tdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
-    useColors: true // colored output from test results
+    ui: 'bdd', 		// the TDD UI is being used in extension.test.ts (suite, test, etc.)
+    useColors: true, // colored output from test results
+    timeout: 600000,
+
 });
 
-module.exports = testRunner;
+module.exports = testRunner;

data/client/vscode/testFixture/completion.rb

@@ -0,0 +1 @@
+Object

data/exe/yoda

@@ -5,23 +5,4 @@ if Dir.exist?(File.join(__dir__, "..", ".git"))
 end
 
 require 'yoda'
-require 'optparse'
-
-opt = OptionParser.new("Usage: yoda [options]") do |opt|
-end
-
-argv = opt.parse(ARGV)
-
-case argv.first
-when 'setup'
-  require 'pry'
-  Pry::rescue { Yoda::Runner::Setup.run(argv[1]) }
-when 'infer'
-  require 'pry'
-  Pry::rescue { Yoda::Runner::Infer.run(argv[1]) }
-when 'server'
-  Yoda::Server.new.run
-else
-  puts opt.help
-  exit 1
-end
+Yoda::Commands::Top.start(ARGV)

data/lib/yoda.rb

@@ -1,11 +1,12 @@
 module Yoda
   require "yoda/version"
+  require "yoda/commands"
+  require "yoda/errors"
   require "yoda/evaluation"
   require "yoda/model"
   require "yoda/store"
   require "yoda/server"
   require "yoda/parsing"
   require "yoda/typing"
-  require "yoda/runner"
   require "yoda/yard_extensions"
 end

data/lib/yoda/commands.rb

@@ -0,0 +1,34 @@
+require 'thor'
+
+module Yoda
+  # Commands module has handler for each cli command.
+  module Commands
+    require 'yoda/commands/base'
+    require 'yoda/commands/file_cursor_parsable'
+    require 'yoda/commands/setup'
+    require 'yoda/commands/infer'
+    require 'yoda/commands/complete'
+
+    class Top < Thor
+      desc 'setup', 'Setup indexes for current Ruby version and project gems'
+      def setup
+        Commands::Setup.run
+      end
+
+      desc 'infer POSITION', 'Infer the type of value at the specified position'
+      def infer(position)
+        Commands::Infer.run(position)
+      end
+
+      desc 'complete POSITION', 'Provide completion candidates for the specified position'
+      def complete(position)
+        Commands::Complete.run(position)
+      end
+
+      desc 'server', 'Start Language Server'
+      def server
+        Server.new.run
+      end
+    end
+  end
+end

data/lib/yoda/commands/base.rb

@@ -0,0 +1,10 @@
+module Yoda
+  module Commands
+    # @abstract
+    class Base
+      def self.run(*args)
+        self.new(*args).run
+      end
+    end
+  end
+end

data/lib/yoda/commands/complete.rb

@@ -0,0 +1,36 @@
+module Yoda
+  module Commands
+    class Complete < Base
+      include FileCursorParsable
+
+      attr_reader :filename_with_position
+
+      # @param filename_with_position [String] position representation with the format `path/to/file:line_num:character_num`
+      def initialize(filename_with_position)
+        @filename_with_position = filename_with_position
+      end
+
+      def run
+        project.build_cache
+        puts create_signature_help(worker.current_node_signature)
+      end
+
+      private
+
+      # @param signature [Model::NodeSignature, nil]
+      # @return [String, nil]
+      def create_signature_help(signature)
+        return nil unless signature
+        signature.descriptions.map(&:title).join("\n")
+      end
+
+      def worker
+        @worker ||= Evaluation::CurrentNodeExplain.new(project.registry, File.read(filename), position)
+      end
+
+      def project
+        @project ||= Store::Project.new(Dir.pwd)
+      end
+    end
+  end
+end

data/lib/yoda/commands/file_cursor_parsable.rb

@@ -0,0 +1,29 @@
+module Yoda
+  module Commands
+    # Provide parsing methods of positon representation with the format `path/to/file:line_num:character_num`
+    module FileCursorParsable
+      private
+
+      # Returns a cursor literal to parse.
+      # @abstract
+      # @return [String]
+      def filename_with_position
+        fail NotImplementedError
+      end
+
+      # @return [String, nil] represents the filename part.
+      def filename
+        @filename ||= filename_with_position.split(':').first
+      end
+
+      # Parse location part of cursor literal and returns the parsed location.
+      # @return [Parsing::Location]
+      def position
+        @position ||= begin
+          row, column = filename_with_position.split(':').slice(1..2)
+          Parsing::Location.new(row: row.to_i, column: column.to_i)
+        end
+      end
+    end
+  end
+end

data/lib/yoda/{runner → commands}/infer.rb

@@ -1,20 +1,15 @@
 module Yoda
-  module Runner
-    class Infer
+  module Commands
+    class Infer < Base
       attr_reader :filename_with_position
 
-      # @param filename_with_position [String]
-      def self.run(filename_with_position)
-        new(filename_with_position).run
-      end
-
-      # @param filename_with_position [String]
+      # @param filename_with_position [String] position representation with the format `path/to/file:line_num:character_num`
       def initialize(filename_with_position)
         @filename_with_position = filename_with_position
       end
 
       def run
-        project.setup
+        project.build_cache
         puts create_signature_help(worker.current_node_signature)
       end
 

data/lib/yoda/commands/setup.rb

@@ -0,0 +1,37 @@
+module Yoda
+  module Commands
+    class Setup < Base
+      # @return [String]
+      attr_reader :dir
+
+      # @return [true, false]
+      attr_reader :force_build
+
+      # @param dir [String]
+      def initialize(dir: nil, force_build: false)
+        @dir = dir || Dir.pwd
+        @force_build = force_build
+      end
+
+      def run
+        build_core_index
+        if File.exist?(File.expand_path('Gemfile.lock', dir)) || force_build
+          STDERR.puts 'Building index for the current project...'
+          force_build ? project.rebuild_cache(progress: true) : project.build_cache(progress: true)
+        else
+          STDERR.puts 'Skipped building project index because Gemfile.lock is not exist for the current dir'
+        end
+      end
+
+      def project
+        @project ||= Store::Project.new(dir)
+      end
+
+      private
+
+      def build_core_index
+        Store::Actions::BuildCoreIndex.run unless Store::Actions::BuildCoreIndex.exists?
+      end
+    end
+  end
+end

data/lib/yoda/errors.rb

@@ -0,0 +1,34 @@
+module Yoda
+  # @abstract
+  class BaseError < ::StandardError
+  end
+
+  class GemImportError < BaseError
+    # @return [String]
+    attr_reader :name, :version
+
+    def initialize(name:, version:)
+      @name = name
+      @version = version
+      super(msg)
+    end
+
+    def msg
+      "Failed to import #{name} #{version}"
+    end
+  end
+
+  class CoreImportError < BaseError
+    # @return [String]
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+      super(msg)
+    end
+
+    def msg
+      "Failed to import Ruby #{name} Library"
+    end
+  end
+end

data/lib/yoda/evaluation/evaluator.rb

@@ -76,6 +76,7 @@ module Yoda
       def evaluation_context
         @evaluation_context ||= begin
           fail RuntimeError, "The namespace #{scope.scope_name} (#{scope}) is not registered" unless scope_constant
+          fail RuntimeError, "The namespace for #{scope} (#{scope.scope_name}) is not registered" unless receiver
           lexical_scope = Typing::LexicalScope.new(scope_constant, scope.ancestor_scopes)
           context = Typing::Context.new(registry: registry, caller_object: receiver, lexical_scope: lexical_scope)
           context.env.bind_method_parameters(current_method_signature) if current_method_signature
@@ -89,6 +90,7 @@ module Yoda
         @current_method_signature ||= Store::Query::FindSignature.new(registry).select(scope_constant, scope.name.to_s)&.first
       end
 
+      # @return [Store::Objects::Base, nil]
       def receiver
         @receiver ||= begin
           if scope.kind == :method

data/lib/yoda/server.rb

@@ -1,4 +1,5 @@
 require 'language_server-protocol'
+require 'securerandom'
 
 module Yoda
   class Server
@@ -6,8 +7,9 @@ module Yoda
     require 'yoda/server/signature_provider'
     require 'yoda/server/hover_provider'
     require 'yoda/server/definition_provider'
+    require 'yoda/server/initialization_provider'
     require 'yoda/server/deserializer'
-    require 'yoda/server/client_info'
+    require 'yoda/server/session'
 
     LSP = ::LanguageServer::Protocol
 
@@ -21,8 +23,8 @@ module Yoda
     # @type ::LanguageServer::Protocol::Transport::Stdio::Writer
     attr_reader :writer
 
-    # @type ClientInfo
-    attr_reader :client_info
+    # @return [Responser]
+    attr_reader :session
 
     # @type CompletionProvider
     attr_reader :completion_provider
@@ -36,17 +38,26 @@ module Yoda
     # @type DefinitionProvider
     attr_reader :definition_provider
 
+    # @return [Array<Hash>]
+    attr_reader :after_notifications
+
     def initialize
       @reader = LSP::Transport::Stdio::Reader.new
       @writer = LSP::Transport::Stdio::Writer.new
+      @after_notifications = []
     end
 
     def run
       reader.read do |request|
         begin
           if result = callback(request)
-            writer.write(id: request[:id], result: result)
+            if result.is_a?(LanguageServer::Protocol::Interface::ResponseError)
+              send_error(id: request[:id], error: result)
+            else
+              send_response(id: request[:id], result: result)
+            end
           end
+          process_after_notifications if session&.client_initialized
         rescue StandardError => ex
           STDERR.puts ex
           STDERR.puts ex.backtrace
@@ -54,6 +65,30 @@ module Yoda
       end
     end
 
+    def process_after_notifications
+      while notification = after_notifications.pop
+        send_notification(**notification)
+      end
+    end
+
+    # @param method [String]
+    # @param params [Object]
+    def send_notification(method:, params:)
+      writer.write(method: method, params: params)
+    end
+
+    # @param id [String]
+    # @param result [Object]
+    def send_response(id:, result:)
+      writer.write(id: id, result: result)
+    end
+
+    # @param method [String]
+    # @param error [Object]
+    def send_error(id:, error:)
+      writer.write(id: id, error: error)
+    end
+
     def callback(request)
       if method_name = resolve(request_registrations, request[:method])
         send(method_name, self.class.deserialize(request[:params] || {}))
@@ -65,10 +100,12 @@ module Yoda
 
     # @param hash [Hash]
     # @param key [String, Symbol]
+    # @return [Symbol, nil]
     def resolve(hash, key)
-      key.to_s.split('/').reduce(hash) do |scope, key|
+      resolved = key.to_s.split('/').reduce(hash) do |scope, key|
         (scope || {})[key.to_sym]
       end
+      resolved.is_a?(Symbol) && resolved
     end
 
     def request_registrations
@@ -97,12 +134,13 @@ module Yoda
     end
 
     def handle_initialize(params)
-      @client_info = ClientInfo.new(params[:root_uri])
-      @completion_provider = CompletionProvider.new(@client_info)
-      @hover_provider = HoverProvider.new(@client_info)
-      @signature_provider = SignatureProvider.new(@client_info)
-      @definition_provider = DefinitionProvider.new(@client_info)
-      client_info.setup
+      @session = Session.new(params[:root_uri])
+      @completion_provider = CompletionProvider.new(@session)
+      @hover_provider = HoverProvider.new(@session)
+      @signature_provider = SignatureProvider.new(@session)
+      @definition_provider = DefinitionProvider.new(@session)
+
+      (InitializationProvider.new(@session).provide || []).each { |notification| after_notifications.push(notification) }
 
       LSP::Interface::InitializeResult.new(
         capabilities: LSP::Interface::ServerCapabilities.new(
@@ -113,7 +151,7 @@ module Yoda
             ),
           ),
           completion_provider: LSP::Interface::CompletionOptions.new(
-            resolve_provider: true,
+            resolve_provider: false,
             trigger_characters: ['.', '@', '[', ':', '!', '<'],
           ),
           hover_provider: true,
@@ -123,9 +161,16 @@ module Yoda
           ),
         ),
       )
+    rescue => e
+      LanguageServer::Protocol::Interface::ResponseError.new(
+        message: "Failed to initialize yoda: #{e.class} #{e.message}",
+        code: LanguageServer::Protocol::Constant::InitializeError::UNKNOWN_PROTOCOL_VERSION,
+        data: LanguageServer::Protocol::Interface::InitializeError.new(retry: false),
+      )
     end
 
     def handle_initialized(_params)
+      session.client_initialized = true
     end
 
     def handle_shutdown(_params)
@@ -143,19 +188,19 @@ module Yoda
       def handle_text_document_did_open(params)
         uri = params[:text_document][:uri]
         text = params[:text_document][:text]
-        client_info.file_store.store(uri, text)
+        session.file_store.store(uri, text)
       end
 
       def handle_text_document_did_save(params)
         uri = params[:text_document][:uri]
 
-        client_info.reparse_doc(uri)
+        session.reparse_doc(uri)
       end
 
       def handle_text_document_did_change(params)
         uri = params[:text_document][:uri]
         text = params[:content_changes].first[:text]
-        client_info.file_store.store(uri, text)
+        session.file_store.store(uri, text)
       end
 
       def handle_text_document_completion(params)