Impl adhoc provider

Author: mtsmfm

language_server.gemspec

@@ -33,4 +33,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-byebug"
   spec.add_development_dependency "minitest-power_assert"
   spec.add_development_dependency "m"
+  spec.add_development_dependency "awesome_print"
 end

lib/language_server.rb

@@ -4,7 +4,9 @@
 require "language_server/protocol/stdio"
 require "language_server/linter/ruby_wc"
 require "language_server/completion_provider/rcodetools"
+require "language_server/completion_provider/ad_hoc"
 require "language_server/file_store"
+require "language_server/project"
 
 require "json"
 require "logger"
@@ -18,7 +20,7 @@ def logger
     def run
       writer = Protocol::Stdio::Writer.new
       reader = Protocol::Stdio::Reader.new
-      file_store = FileStore.new
+      variables = {}
 
       reader.read do |request|
         method = request[:method].to_sym
@@ -30,10 +32,11 @@ def run
         }
 
         if subscriber
+          keys = subscriber.parameters.map(&:last)
           result = subscriber.call(
             {
-              request: request, notifier: writer.method(:notify), file_store: file_store
-            }.select {|k, _| subscriber.parameters.map(&:last).include?(k) }
+              request: request, notifier: writer.method(:notify), variables: variables
+            }.merge(variables).select {|k, _| keys.include?(k) }
           )
 
           if request[:id]
@@ -54,7 +57,10 @@ def on(method, &callback)
     end
   end
 
-  on :initialize do
+  on :initialize do |request:, variables:|
+    variables[:file_store] = FileStore.new(load_paths: $LOAD_PATH, remote_root: request[:params][:rootPath], local_root: Dir.getwd)
+    variables[:project] = Project.new(variables[:file_store])
+
     Protocol::Interfaces::InitializeResult.new(
       capabilities: Protocol::Interfaces::ServerCapabilities.new(
         text_document_sync: Protocol::Interfaces::TextDocumentSyncOptions.new(
@@ -72,10 +78,11 @@ def on(method, &callback)
     exit
   end
 
-  on :"textDocument/didChange" do |request:, notifier:, file_store:|
+  on :"textDocument/didChange" do |request:, notifier:, file_store:, project:|
     uri = request[:params][:textDocument][:uri]
     text = request[:params][:contentChanges][0][:text]
     file_store.cache(uri, text)
+    project.recalculate_result(uri)
 
     diagnostics = Linter::RubyWC.new(text).call.map do |error|
       Protocol::Interfaces::Diagnostic.new(
@@ -103,12 +110,13 @@ def on(method, &callback)
     )
   end
 
-  on :"textDocument/completion" do |request:, file_store:|
+  on :"textDocument/completion" do |request:, file_store:, project:|
     uri = request[:params][:textDocument][:uri]
-    line, character = request[:params][:position].fetch_values(:line, :character)
+    line, character = request[:params][:position].fetch_values(:line, :character).map(&:to_i)
 
     [
-      CompletionProvider::Rcodetools.new(uri: uri, line: line.to_i, character: character.to_i, file_store: file_store)
+      CompletionProvider::AdHoc.new(uri: uri, line: line, character: character, project: project),
+      CompletionProvider::Rcodetools.new(uri: uri, line: line, character: character, file_store: file_store)
     ].flat_map(&:call)
   end
 end

lib/language_server/completion_provider/ad_hoc.rb

@@ -0,0 +1,45 @@
+require "language_server/project"
+
+module LanguageServer
+  module CompletionProvider
+    class AdHoc
+      def initialize(uri:, line:, character:, project:)
+        @uri = uri
+        @line = line
+        @character = character
+        @project = project
+      end
+
+      def call
+        (project.constants(uri: uri, line: line, character: character).map {|c|
+          Protocol::Interfaces::CompletionItem.new(
+            label: c.name,
+            detail: c.full_name,
+            documentation: "#{c.remote_path}##{c.lineno}",
+            kind: Protocol::Constants::CompletionItemKind::ENUM
+          )
+        } +
+        project.classes(uri: uri, line: line, character: character).map {|c|
+          Protocol::Interfaces::CompletionItem.new(
+            label: c.name,
+            detail: c.full_name,
+            documentation: "#{c.remote_path}##{c.lineno}",
+            kind: Protocol::Constants::CompletionItemKind::CLASS
+          )
+        } +
+        project.modules(uri: uri, line: line, character: character).map {|m|
+          Protocol::Interfaces::CompletionItem.new(
+            label: m.name,
+            detail: m.full_name,
+            documentation: "#{m.remote_path}##{m.lineno}",
+            kind: Protocol::Constants::CompletionItemKind::MODULE
+          )
+        }).uniq(&:label)
+      end
+
+      private
+
+      attr_reader :uri, :line, :character, :project
+    end
+  end
+end

lib/language_server/completion_provider/rcodetools.rb

@@ -38,7 +38,7 @@ def call
       private
 
       def source
-        @file_store.read(@uri)
+        @file_store.read_remote_uri(@uri)
       end
     end
   end

lib/language_server/file_store.rb

@@ -4,40 +4,80 @@ module LanguageServer
   class FileStore
     include Enumerable
 
-    def initialize(load_paths = [])
+    class FilePath
+      class << self
+        def from_remote_uri(remote_root:, local_root:, remote_uri:)
+          new(remote_root: remote_root, local_root: local_root, local_path: URI(remote_uri).path.sub(remote_root, local_root))
+        end
+      end
+
+      attr_reader :local_root, :remote_root, :local_path
+
+      def initialize(remote_root:, local_root:, local_path:)
+        @remote_root = remote_root
+        @local_root = local_root
+        @local_path = local_path
+      end
+
+      def remote_path
+        @remote_path ||= local_path.sub(local_root, remote_root)
+      end
+
+      def eql?(other)
+        self.class == other.class && remote_path == other.remote_path
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def hash
+        self.remote_path.hash
+      end
+    end
+
+    def initialize(load_paths: [], remote_root: Dir.getwd, local_root: Dir.getwd)
       @load_paths = load_paths
+      @remote_root = remote_root
+      @local_root = local_root
     end
 
-    def cache(uri_or_path, content)
-      cache_store[to_path(uri_or_path)] = content
+    def cache(remote_uri, content)
+      cache_store[path_from_remote_uri(remote_uri)] = content
     end
 
-    def read(uri_or_path)
-      path = to_path(uri_or_path)
+    def path_from_remote_uri(remote_uri)
+      FilePath.from_remote_uri(local_root: local_root, remote_root: remote_root, remote_uri: remote_uri)
+    end
 
+    def read(path)
       if exists_on_cache?(path)
         read_from_cache(path)
       else
         read_from_local(path)
       end
     end
 
-    def each(&block)
-      all_file_paths.each do |path|
-        block.call(read(path))
-      end
+    def read_remote_uri(remote_uri)
+      read(path_from_remote_uri(remote_uri))
     end
 
-    def all_file_paths
-      cache_store.keys + load_paths.flat_map {|path| Dir.glob(File.join(path, "**", "*.rb")) }
+    def each(&block)
+      all_paths.each do |path|
+        block.call(read(path), path)
+      end
     end
 
     private
 
-    attr_reader :load_paths
+    attr_reader :load_paths, :remote_root, :local_root
 
-    def to_path(uri_or_path)
-      URI(uri_or_path).path
+    def all_paths
+      (cache_store.keys + load_paths.flat_map {|path|
+        Dir.glob(File.join(path, "**", "*.rb"))
+      }.map {|path|
+        FilePath.new(local_root: local_root, remote_root: remote_root, local_path: path)
+      }).uniq
     end
 
     def exists_on_cache?(path)
@@ -49,7 +89,7 @@ def read_from_cache(path)
     end
 
     def read_from_local(path)
-      File.read(path)
+      File.read(path.local_path)
     end
 
     def cache_store

lib/language_server/project.rb

@@ -0,0 +1,67 @@
+require 'language_server/project/parser'
+
+module LanguageServer
+  class Project
+    def initialize(file_store)
+      @file_store = file_store
+      @result_store = {}
+
+      fetch_result
+    end
+
+    def recalculate_result(uri)
+      path = file_store.path_from_remote_uri(uri)
+      result_store[path] = calculate(file_store.read(path), path)
+    end
+
+    def constants(uri: nil, line: nil, character: nil)
+      node = find_nearest_node(uri: uri, line: line, character: character) if uri && line && character
+
+      lazy_constants.select {|n| n.names[0..-2] == Array(node && node.names).first(n.names.size - 1) }.force
+    end
+
+    def modules(uri: nil, line: nil, character: nil)
+      node = find_nearest_node(uri: uri, line: line, character: character) if uri && line && character
+
+      lazy_modules.select {|n| n.names[0..-2] == Array(node && node.names).first(n.names.size - 1) }.force
+    end
+
+    def classes(uri: nil, line: nil, character: nil)
+      node = find_nearest_node(uri: uri, line: line, character: character) if uri && line && character
+
+      lazy_classes.select {|n| n.names[0..-2] == Array(node && node.names).first(n.names.size - 1) }.force
+    end
+
+    private
+
+    attr_reader :file_store, :result_store
+
+    def lazy_constants
+      result_store.each_value.lazy.flat_map(&:constants)
+    end
+
+    def lazy_modules
+      result_store.each_value.lazy.flat_map(&:modules)
+    end
+
+    def lazy_classes
+      result_store.each_value.lazy.flat_map(&:classes)
+    end
+
+    def fetch_result
+      file_store.each {|content, path|
+        result_store[path] = calculate(content, path)
+      }
+    end
+
+    def find_nearest_node(uri:, line:, character:)
+      result = result_store[file_store.path_from_remote_uri(uri)]
+
+      (result.modules + result.classes).select {|node| node.lines.include?(line) }.min_by {|node| node.lines.size }
+    end
+
+    def calculate(content, path)
+      Parser.parse(content, path)
+    end
+  end
+end