language_server 0.9.0 → 0.10.0

data/lib/language_server/completion_provider/ad_hoc.rb

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

data/lib/language_server/completion_provider/rcodetools.rb

@@ -28,16 +28,16 @@ module LanguageServer
           Protocol::Interface::CompletionItem.new(
             label: method_name,
             detail: description,
-            kind: Protocol::Constant::CompletionItemKind::METHOD
+            kind: Protocol::Constant::CompletionItemKind::METHOD,
           )
         end
       end
 
       private
 
-      def source
-        @file_store.read_remote_uri(@uri)
-      end
+        def source
+          @file_store.read_remote_uri(@uri)
+        end
     end
   end
 end

data/lib/language_server/definition_provider/ad_hoc.rb

@@ -15,20 +15,20 @@ module LanguageServer
             range: Protocol::Interface::Range.new(
               start: Protocol::Interface::Position.new(
                 line: n.lines.begin,
-                character: 0
+                character: 0,
               ),
               end: Protocol::Interface::Position.new(
                 line: n.lines.end,
-                character: 0
-              )
-            )
+                character: 0,
+              ),
+            ),
           )
         end
       end
 
       private
 
-      attr_reader :uri, :line, :character, :project
+        attr_reader :uri, :line, :character, :project
     end
   end
 end

data/lib/language_server/file_store.rb

@@ -64,36 +64,36 @@ module LanguageServer
 
     def each(&block)
       all_paths.each do |path|
-        block.call(read(path), path)
+        yield(read(path), path)
       end
     end
 
     private
 
-    attr_reader :load_paths, :remote_root, :local_root
+      attr_reader :load_paths, :remote_root, :local_root
 
-    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 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)
-      cache_store.key?(path)
-    end
+      def exists_on_cache?(path)
+        cache_store.has_key?(path)
+      end
 
-    def read_from_cache(path)
-      cache_store[path]
-    end
+      def read_from_cache(path)
+        cache_store[path]
+      end
 
-    def read_from_local(path)
-      File.read(path.local_path)
-    end
+      def read_from_local(path)
+        File.read(path.local_path)
+      end
 
-    def cache_store
-      @cache_store ||= {}
-    end
+      def cache_store
+        @cache_store ||= {}
+      end
   end
 end

data/lib/language_server/linter/rubocop.rb

@@ -1,22 +1,21 @@
 begin
-  require 'rubocop'
+  require "rubocop"
 rescue LoadError
 end
 
 module LanguageServer
   module Linter
     class Rubocop
-      def initialize(source, config_path="")
+      def initialize(source, config_path = "")
         @source = source
         @config_path = config_path
       end
 
-
       def call
         return [] unless defined? ::RuboCop
         args = []
-        args += ["--config", @config_path] if @config_path != ''
-        args += ["--format", "json","--stdin", "lsp_buffer.rb"]
+        args += ["--config", @config_path] if @config_path != ""
+        args += ["--format", "json", "--stdin", "lsp_buffer.rb"]
         o = nil
         begin
           $stdin = StringIO.new(@source)
@@ -32,24 +31,23 @@ module LanguageServer
           $stdout = STDOUT
         end
         return [] unless o
-        JSON
-          .parse(o)['files'].map { |v| v['offenses'] }
-          .flatten
-          .map { |v| Error.new(line_num: v['location']['line'].to_i - 1, message: v['message'], type: convert_type(v['severity'])) }
+        JSON.
+          parse(o)["files"].map { |v| v["offenses"] }.
+          flatten.
+          map { |v| Error.new(line_num: v["location"]["line"].to_i - 1, message: v["message"], type: convert_type(v["severity"])) }
       end
 
       private
 
-      def convert_type(type)
-        case type
-        when 'refactor' then 'warning'
-        when 'convention' then 'warning'
-        when 'warning' then 'warning'
-        when 'error' then 'error'
-        when 'fatal' then 'error'
+        def convert_type(type)
+          case type
+          when "refactor" then "warning"
+          when "convention" then "warning"
+          when "warning" then "warning"
+          when "error" then "error"
+          when "fatal" then "error"
+          end
         end
-      end
-
     end
   end
 end

data/lib/language_server/linter/ruby_wc.rb

@@ -3,10 +3,11 @@ require "stringio"
 module LanguageServer
   module Linter
     class Error
-      attr_reader :line_num, :message, :type
+      attr_reader :line_num, :characters, :message, :type
 
-      def initialize(line_num:, message:, type:)
+      def initialize(line_num:, characters: 0..0, message:, type:)
         @line_num = line_num
+        @characters = characters
         @message = message
         @type = type
       end
@@ -16,7 +17,7 @@ module LanguageServer
       end
 
       def ==(other)
-        line_num == other.line_num && message == other.message
+        line_num == other.line_num && characters == other.characters && message == other.message
       end
     end
 
@@ -26,55 +27,65 @@ module LanguageServer
       end
 
       def call
-        error_message.scan(/.+:(\d+):\s*(.+?)[,:]\s(.+)/).map do |line_num, type,  message|
-          Error.new(line_num: line_num.to_i - 1, message: message, type: type)
+        error_message.scan(/.+:(\d+):\s*(.+?)[,:]\s(.+)/).map do |line_num, type, message|
+          Error.new(line_num: line_num.to_i - 1, characters: get_characters_from_error_message(error_message, line_num.to_i - 1), message: message, type: type)
         end
       end
 
       private
 
-      # Since Ruby 2.4, syntax error information is outputted to Exception#message instead of stderr
-      if begin; stderr = $stderr; $stderr = StringIO.new; RubyVM::InstructionSequence.compile('='); rescue SyntaxError => e; e.message != 'compile error'; ensure; $stderr = stderr; end
-        def error_message
-          with_verbose do
-            begin
-              capture_stderr { RubyVM::InstructionSequence.compile(@source) }
-            rescue SyntaxError => e
-              e.message
+        # Since Ruby 2.4, syntax error information is outputted to Exception#message instead of stderr
+        if begin; stderr = $stderr; $stderr = StringIO.new; RubyVM::InstructionSequence.compile("="); rescue SyntaxError => e; e.message != "compile error"; ensure; $stderr = stderr; end
+          def error_message
+            with_verbose do
+              begin
+                capture_stderr { RubyVM::InstructionSequence.compile(@source) }
+              rescue SyntaxError => e
+                e.message
+              end
             end
           end
-        end
-      else
-        def error_message
-          with_verbose do
-            capture_stderr do
-              begin
-                RubyVM::InstructionSequence.compile(@source)
-              rescue SyntaxError
+        else
+          def error_message
+            with_verbose do
+              capture_stderr do
+                begin
+                  RubyVM::InstructionSequence.compile(@source)
+                rescue SyntaxError
+                end
               end
             end
           end
         end
-      end
 
-      def with_verbose
-        origin = $VERBOSE
-        $VERBOSE = true
-        yield
-      ensure
-        $VERBOSE = origin
-      end
+        def with_verbose
+          origin = $VERBOSE
+          $VERBOSE = true
+          yield
+        ensure
+          $VERBOSE = origin
+        end
 
-      def capture_stderr
-        origin = $stderr
-        $stderr = StringIO.new
+        def capture_stderr
+          origin = $stderr
+          $stderr = StringIO.new
 
-        yield
+          yield
 
-        $stderr.string
-      ensure
-        $stderr = origin
-      end
+          $stderr.string
+        ensure
+          $stderr = origin
+        end
+
+        def get_characters_from_error_message(error_message, line_index)
+          error_mark_included_line = error_message.split("\n")[2]
+
+          if !error_mark_included_line.nil? && character_start = error_mark_included_line.index("^")
+            Range.new(character_start, character_start + 1)
+          else
+            Range.new(0, @source.split("\n")[line_index].length - 1)
+          end
+        end
     end
   end
 end

data/lib/language_server/logger.rb

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

data/lib/language_server/project.rb

@@ -1,4 +1,4 @@
-require 'language_server/project/parser'
+require "language_server/project/parser"
 
 module LanguageServer
   class Project
@@ -12,11 +12,11 @@ module LanguageServer
     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 }
+      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
+      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)
@@ -27,58 +27,58 @@ module LanguageServer
     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
+      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
+      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
+      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
+      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_constants
+        result_store.each_value.lazy.flat_map(&:constants)
+      end
 
-    def lazy_classes
-      result_store.each_value.lazy.flat_map(&:classes)
-    end
+      def lazy_modules
+        result_store.each_value.lazy.flat_map(&:modules)
+      end
 
-    def fetch_result
-      file_store.each {|content, path|
-        calculate(content, path)
-      }
-    end
+      def lazy_classes
+        result_store.each_value.lazy.flat_map(&:classes)
+      end
 
-    def find_nearest_node(uri:, line:, character:)
-      result = result_store[file_store.path_from_remote_uri(uri)]
+      def fetch_result
+        file_store.each { |content, path|
+          calculate(content, path)
+        }
+      end
 
-      (result.modules + result.classes).select {|node| node.lines.include?(line) }.min_by {|node| node.lines.size }
-    end
+      def find_nearest_node(uri:, line:, character:)
+        result = result_store[file_store.path_from_remote_uri(uri)]
 
-    def calculate(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)
+        (result.modules + result.classes).select { |node| node.lines.include?(line) }.min_by { |node| node.lines.size }
       end
 
-      result_store[path] = result if result
-    end
+      def calculate(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