language_server 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7afd0094b57b216afc44723653a9bd07aa1f7910
-  data.tar.gz: 1c440fef75c1492a7c4048e31f70123cdcd5c049
+  metadata.gz: bd9f5e6f9f5a2519287df5f2fde05e24d4db7b4f
+  data.tar.gz: 84aa9599f3d9d417ddc6d7e8b326e08136a472bd
 SHA512:
-  metadata.gz: e9826d5f5402567b90eac9a722d4e4baa0cea4b9d388df2b263641a9a28190759f86cb739b56f355365302b1640c6c1f90890ae8abe91b1c08b99af8443c5864
-  data.tar.gz: f1eb2ab1791cdd3d1440500603e00498e886f68ba1e71f59e615e2cac6a1d59cc0fce0dbdfd0586d70369c32dc1b403b29d9bbc61fe60756cd82db3a6f0f1b01
+  metadata.gz: 8b70d5f63f934908bb155bba4a9aa76424ceda6afbc872fa13e84c2e5c283e518ee5f68c50ec818eb456e14f0fee0b160868c05e4f290f2016cb798b648026dc
+  data.tar.gz: ef92ada00816057dce269cc9bb3fd6ed070f38403c80123e991ef67e50abaa3b736beeae83dba2d72d837817181f1ef5f6fab93050a432c243928f6d36b273c1

data/bin/console

@@ -6,6 +6,12 @@ require "language_server"
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
+def project
+  @project ||= LanguageServer::Project.new(
+    LanguageServer::FileStore.new(load_paths: $LOAD_PATH, remote_root: ENV['LANGUAGE_SERVER_RUBY_REMOTE_ROOT'], local_root: Dir.getwd)
+  )
+end
+
 # (If you use this, don't forget to add pry to your Gemfile!)
 require "pry-byebug"
 Pry.start

data/circle.yml

@@ -25,7 +25,6 @@ jobs:
           name: test
           command: |
             set -x
-            docker-compose run node bin/generate_files
             docker-compose run app bin/m
             docker-compose run ruby-2-3 bin/m
             docker-compose run ruby-2-2 bin/m

data/docker-compose.yml

@@ -4,6 +4,8 @@ services:
     build: &app-build
       context: .
       dockerfile: Dockerfile.development
+    environment:
+      LANGUAGE_SERVER_RUBY_REMOTE_ROOT: $PWD
     volumes:
       - mtsmfm-language-server-sync:/app:nocopy
       - home:/home/ruby
@@ -22,13 +24,6 @@ services:
       <<: *app-build
       args:
         RUBY_VERSION: 2.2
-  node:
-    build:
-      context: .
-      dockerfile: Dockerfile-node.development
-    volumes:
-      - mtsmfm-language-server-sync:/app:nocopy
-      - home:/home/node
 volumes:
   mtsmfm-language-server-sync:
     external: true

data/language_server.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "rcodetools"
+  spec.add_dependency "language_server-protocol", "0.3.0"
 
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"

data/lib/language_server/completion_provider/ad_hoc.rb

@@ -12,27 +12,27 @@ module LanguageServer
 
       def call
         (project.constants(uri: uri, line: line, character: character).map {|c|
-          Protocol::Interfaces::CompletionItem.new(
+          Protocol::Interface::CompletionItem.new(
             label: c.name,
             detail: c.full_name,
             documentation: "#{c.remote_path}##{c.lineno}",
-            kind: Protocol::Constants::CompletionItemKind::ENUM
+            kind: Protocol::Constant::CompletionItemKind::ENUM
           )
         } +
         project.classes(uri: uri, line: line, character: character).map {|c|
-          Protocol::Interfaces::CompletionItem.new(
+          Protocol::Interface::CompletionItem.new(
             label: c.name,
             detail: c.full_name,
             documentation: "#{c.remote_path}##{c.lineno}",
-            kind: Protocol::Constants::CompletionItemKind::CLASS
+            kind: Protocol::Constant::CompletionItemKind::CLASS
           )
         } +
         project.modules(uri: uri, line: line, character: character).map {|m|
-          Protocol::Interfaces::CompletionItem.new(
+          Protocol::Interface::CompletionItem.new(
             label: m.name,
             detail: m.full_name,
             documentation: "#{m.remote_path}##{m.lineno}",
-            kind: Protocol::Constants::CompletionItemKind::MODULE
+            kind: Protocol::Constant::CompletionItemKind::MODULE
           )
         }).uniq(&:label)
       end

data/lib/language_server/completion_provider/rcodetools.rb

@@ -1,6 +1,4 @@
-require "language_server/protocol/interfaces/completion_item"
-require "language_server/protocol/constants/completion_item_kind"
-
+require "language_server/protocol"
 require "rcodetools/completion"
 
 module LanguageServer
@@ -27,10 +25,10 @@ module LanguageServer
         _, candidates = Filter.run(source, lineno: @line + 1, column: @character)
         candidates.map do |candidate|
           method_name, description = candidate.split(/\0/, 2)
-          Protocol::Interfaces::CompletionItem.new(
+          Protocol::Interface::CompletionItem.new(
             label: method_name,
             detail: description,
-            kind: Protocol::Constants::CompletionItemKind::METHOD
+            kind: Protocol::Constant::CompletionItemKind::METHOD
           )
         end
       end

data/lib/language_server/definition_provider/ad_hoc.rb

@@ -0,0 +1,34 @@
+module LanguageServer
+  module DefinitionProvider
+    class AdHoc
+      def initialize(uri:, line:, character:, project:)
+        @uri = uri
+        @line = line
+        @character = character
+        @project = project
+      end
+
+      def call
+        project.find_definitions(uri: uri, line: line, character: character).map do |n|
+          Protocol::Interface::Location.new(
+            uri: "file://#{n.remote_path}",
+            range: Protocol::Interface::Range.new(
+              start: Protocol::Interface::Position.new(
+                line: n.lines.begin,
+                character: 0
+              ),
+              end: Protocol::Interface::Position.new(
+                line: n.lines.end,
+                character: 0
+              )
+            )
+          )
+        end
+      end
+
+      private
+
+      attr_reader :uri, :line, :character, :project
+    end
+  end
+end

data/lib/language_server/logger.rb

@@ -0,0 +1,37 @@
+require 'logger'
+
+module LanguageServer
+  class << self
+    def logger
+      @logger ||= ::Logger.new(STDERR, formatter: Formatter.new)
+    end
+  end
+
+  class Formatter
+    RESET = "\e[0m"
+    RED = "\e[31m"
+    YELLOW = "\e[33m"
+
+    def call(severity, *rest)
+      msg = default_message(severity, *rest)
+      case severity
+      when 'ERROR'
+        RED + msg + RESET
+      when 'WARN'
+        YELLOW + msg + RESET
+      else
+        msg
+      end
+    end
+
+    private
+
+    def default_message(*args)
+      default_formatter.call(*args)
+    end
+
+    def default_formatter
+      @default_formatter ||= ::Logger::Formatter.new
+    end
+  end
+end

data/lib/language_server/project/node.rb

@@ -21,7 +21,7 @@ end
         end
       end
 
-      attributes :lineno, :path
+      attributes :lineno, :character, :path
 
       def remote_path; path.remote_path; end
       def local_path;  path.local_path;  end
@@ -92,5 +92,69 @@ end
         "<Class #{full_name}#L#{lines.begin}-#{lines.end}>"
       end
     end
+
+    class VarRef < Node
+      attributes :node
+
+      def lines
+        node.lineno..node.lineno
+      end
+
+      def characters
+        node.character..(character - 1)
+      end
+
+      def unshift_namespace(class_or_module)
+        node.unshift_namespace(class_or_module) if node.respond_to?(:unshift_namespace)
+      end
+
+      def names
+        node.names
+      end
+
+      def name
+        node.name
+      end
+
+      def full_name
+        names.join('::')
+      end
+
+      def inspect
+        "<VarRef #{full_name}#L#{lineno}(#{characters})>"
+      end
+    end
+
+    class ConstPathRef < Node
+      attributes :nodes
+
+      def lines
+        (nodes.first.lineno)..(nodes.last.lineno)
+      end
+
+      def characters
+        (nodes.first.characters.begin)..(nodes.last.character)
+      end
+
+      def unshift_namespace(class_or_module)
+        nodes.first.unshift_namespace(class_or_module)
+      end
+
+      def name
+        nodes.last.name
+      end
+
+      def names
+        nodes.flat_map(&:names)
+      end
+
+      def full_name
+        names.join('::')
+      end
+
+      def inspect
+        "<ConstPathRef #{full_name}#L#{lineno}(#{characters})>"
+      end
+    end
   end
 end

data/lib/language_server/project/parser.rb

@@ -5,12 +5,13 @@ module LanguageServer
   class Project
     class Parser < Ripper
       class Result
-        attr_reader :constants, :classes, :modules
+        attr_reader :constants, :classes, :modules, :refs
 
         def initialize
           @constants = []
           @classes = []
           @modules = []
+          @refs = []
         end
       end
 
@@ -27,11 +28,12 @@ module LanguageServer
 
         @path = path
         @result = Result.new
-        @current_constants = []
       end
 
       private
 
+      alias character column
+
       attr_reader :path
 
       def lineno
@@ -39,14 +41,36 @@ module LanguageServer
         super - 1
       end
 
-      def on_const(name)
-        Constant.new(namespaces: [], name: name, value: nil, lineno: lineno, path: path).tap do |c|
-          @current_constants.push(c)
+      def on_var_ref(node)
+        if node.instance_of?(Constant)
+          build_node(VarRef, node: node).tap do |n|
+            result.refs << n
+          end
+        else
+          node
+        end
+      end
+
+      def on_const_path_ref(*nodes)
+        if nodes.all? {|n| [Constant, ConstPathRef, VarRef].include?(n.class) }
+          build_node(ConstPathRef, nodes: nodes).tap do |n|
+            result.refs << n
+          end
+        else
+          nodes
         end
       end
 
+      def on_const(name)
+        build_node(Constant, namespaces: [], name: name, value: nil)
+      end
+
+      def on_def(*args)
+        args.flatten.compact
+      end
+
       def on_int(value)
-        LiteralValue.new(value: value.to_i, lineno: lineno, path: path)
+        build_node(LiteralValue, value: value.to_i)
       end
 
       def on_stmts_add(*args)
@@ -61,20 +85,26 @@ module LanguageServer
       end
 
       def on_module(constant, children)
-        cn = children.select {|child| child.instance_of?(Constant) || child.instance_of?(Module) || child.instance_of?(Class)}
-        Module.new(constant: constant, lineno: lineno, path: path, children: cn).tap do |m|
+        cn = children.select {|child| child.respond_to?(:unshift_namespace) }
+
+        build_node(Module, constant: constant, children: cn).tap do |m|
           result.modules << m
           cn.each {|child| child.unshift_namespace(m) }
         end
       end
 
       def on_class(constant, superclass, children)
-        cn = children.select {|child| child.instance_of?(Constant) || child.instance_of?(Module) || child.instance_of?(Class)}
-        Class.new(constant: constant, superclass: superclass, lineno: lineno, path: path, children: cn).tap do |c|
+        cn = children.select {|child| child.respond_to?(:unshift_namespace) }
+
+        build_node(Class, constant: constant, superclass: superclass, children: cn).tap do |c|
           result.classes << c
           cn.each {|child| child.unshift_namespace(c) }
         end
       end
+
+      def build_node(klass, **args)
+        klass.new({lineno: lineno, character: character, path: path}.merge(args))
+      end
     end
   end
 end

data/lib/language_server/project.rb

@@ -9,9 +9,19 @@ module LanguageServer
       fetch_result
     end
 
+    def find_definitions(uri:, line:, character:)
+      result = result_store[file_store.path_from_remote_uri(uri)]
+
+      ref = result.refs.select {|node| node.lines.include?(line) && node.characters.include?(character) }.min_by {|node| node.characters.size }
+
+      return [] unless ref
+
+      lazy_modules.select {|n| n.full_name == ref.full_name }.force + lazy_classes.select {|n| n.full_name == ref.full_name }.force
+    end
+
     def recalculate_result(uri)
       path = file_store.path_from_remote_uri(uri)
-      result_store[path] = calculate(file_store.read(path), path)
+      calculate(file_store.read(path), path)
     end
 
     def constants(uri: nil, line: nil, character: nil)
@@ -50,7 +60,7 @@ module LanguageServer
 
     def fetch_result
       file_store.each {|content, path|
-        result_store[path] = calculate(content, path)
+        calculate(content, path)
       }
     end
 
@@ -61,7 +71,14 @@ module LanguageServer
     end
 
     def calculate(content, path)
-      Parser.parse(content, path)
+      begin
+        result = Parser.parse(content, path)
+      rescue => e
+        LanguageServer.logger.warn("Parse failed (local: #{path.local_path}, remote: #{path.remote_path})")
+        LanguageServer.logger.warn(e)
+      end
+
+      result_store[path] = result if result
     end
   end
 end

data/lib/language_server/version.rb

@@ -1,3 +1,3 @@
 module LanguageServer
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/lib/language_server.rb

@@ -1,31 +1,40 @@
 require "language_server/version"
-require "language_server/protocol/interfaces"
-require "language_server/protocol/constants"
-require "language_server/protocol/stdio"
+require "language_server/logger"
+require "language_server/protocol"
 require "language_server/linter/ruby_wc"
 require "language_server/completion_provider/rcodetools"
 require "language_server/completion_provider/ad_hoc"
+require "language_server/definition_provider/ad_hoc"
 require "language_server/file_store"
 require "language_server/project"
 
 require "json"
-require "logger"
 
 module LanguageServer
   class << self
-    def logger
-      @logger ||= Logger.new(STDERR)
-    end
-
     def run
-      writer = Protocol::Stdio::Writer.new
-      reader = Protocol::Stdio::Reader.new
+      writer = Protocol::Transport::Stdio::Writer.new
+      reader = Protocol::Transport::Stdio::Reader.new
       variables = {}
 
+      class << writer
+        def respond(id:, result:)
+          write(id: id, result: result)
+
+          LanguageServer.logger.debug("Respond: id: #{id}, result: #{JSON.pretty_generate(result)}")
+        end
+
+        def notify(method:, params: {})
+          write(method: method, params: params)
+
+          LanguageServer.logger.debug("Notify: method: #{method}, params: #{JSON.pretty_generate(params)}")
+        end
+      end
+
       reader.read do |request|
-        method = request[:method].to_sym
+        logger.debug("Receive: #{JSON.pretty_generate(request)}")
 
-        logger.debug("Method: #{method} called")
+        method = request[:method].to_sym
 
         _, subscriber = subscribers.find {|k, _|
           k === method
@@ -61,15 +70,16 @@ module LanguageServer
     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(
-          change: Protocol::Constants::TextDocumentSyncKind::FULL
+    Protocol::Interface::InitializeResult.new(
+      capabilities: Protocol::Interface::ServerCapabilities.new(
+        text_document_sync: Protocol::Interface::TextDocumentSyncOptions.new(
+          change: Protocol::Constant::TextDocumentSyncKind::FULL
         ),
-        completion_provider: Protocol::Interfaces::CompletionOptions.new(
+        completion_provider: Protocol::Interface::CompletionOptions.new(
           resolve_provider: true,
           trigger_characters: %w(.)
-        )
+        ),
+        definition_provider: true
       )
     )
   end
@@ -85,15 +95,15 @@ module LanguageServer
     project.recalculate_result(uri)
 
     diagnostics = Linter::RubyWC.new(text).call.map do |error|
-      Protocol::Interfaces::Diagnostic.new(
+      Protocol::Interface::Diagnostic.new(
         message: error.message,
-        severity: error.warning? ? Protocol::Constants::DiagnosticSeverity::WARNING : Protocol::Constants::DiagnosticSeverity::ERROR,
-        range: Protocol::Interfaces::Range.new(
-          start: Protocol::Interfaces::Position.new(
+        severity: error.warning? ? Protocol::Constant::DiagnosticSeverity::WARNING : Protocol::Constant::DiagnosticSeverity::ERROR,
+        range: Protocol::Interface::Range.new(
+          start: Protocol::Interface::Position.new(
             line: error.line_num,
             character: 0
           ),
-          end: Protocol::Interfaces::Position.new(
+          end: Protocol::Interface::Position.new(
             line: error.line_num,
             character: 0
           )
@@ -103,7 +113,7 @@ module LanguageServer
 
     notifier.call(
       method: :"textDocument/publishDiagnostics",
-      params: Protocol::Interfaces::PublishDiagnosticsParams.new(
+      params: Protocol::Interface::PublishDiagnosticsParams.new(
         uri: uri,
         diagnostics: diagnostics
       )
@@ -119,4 +129,13 @@ module LanguageServer
       CompletionProvider::Rcodetools.new(uri: uri, line: line, character: character, file_store: file_store)
     ].flat_map(&:call)
   end
+
+  on :"textDocument/definition" do |request:, project:|
+    uri = request[:params][:textDocument][:uri]
+    line, character = request[:params][:position].fetch_values(:line, :character).map(&:to_i)
+
+    [
+      DefinitionProvider::AdHoc.new(uri: uri, line: line, character: character, project: project),
+    ].flat_map(&:call)
+  end
 end