ruby_language_server 0.2.0

data/lib/ruby_language_server/good_cop.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RubyLanguageServer
+  class GoodCop < RuboCop::Runner
+    CONFIG_PATH = '/project/.rubocop.yml'
+    FALLBACK_PATH = '/app/.rubocop.yml'
+    @initialization_error = nil
+
+    def initialize
+      config_store = RuboCop::ConfigStore.new
+      config_store.options_config =
+        if File.exist?(CONFIG_PATH)
+          CONFIG_PATH
+        else
+          FALLBACK_PATH
+        end
+      super({}, config_store)
+    rescue Exception => exception
+      RubyLanguageServer.logger.error(exception)
+      @initialization_error = "There was an issue loading the rubocop configuration file: #{exception}.  Maybe you need to add some additional gems to the ide-ruby settings?"
+    end
+
+    # namespace DiagnosticSeverity {
+    #  /**
+    #   * Reports an error.
+    #   */
+    #  export const Error = 1;
+    #  /**
+    #   * Reports a warning.
+    #   */
+    #  export const Warning = 2;
+    #  /**
+    #   * Reports an information.
+    #   */
+    #  export const Information = 3;
+    #  /**
+    #   * Reports a hint.
+    #   */
+    #  export const Hint = 4;
+    # }
+
+    # interface Diagnostic {
+    #  /**
+    #   * The range at which the message applies.
+    #   */
+    #  range: Range;
+    #
+    #  /**
+    #   * The diagnostic's severity. Can be omitted. If omitted it is up to the
+    #   * client to interpret diagnostics as error, warning, info or hint.
+    #   */
+    #  severity?: number;
+    #
+    #  /**
+    #   * The diagnostic's code. Can be omitted.
+    #   */
+    #  code?: number | string;
+    #
+    #  /**
+    #   * A human-readable string describing the source of this
+    #   * diagnostic, e.g. 'typescript' or 'super lint'.
+    #   */
+    #  source?: string;
+    #
+    #  /**
+    #   * The diagnostic's message.
+    #   */
+    #  message: string;
+    # }
+
+    def diagnostic_severity_for(severity)
+      case severity.to_s
+      when 'error', 'fatal'
+        1
+      when 'warning'
+        2
+      when 'refactor', 'convention'
+        3
+      else
+        RubyLanguageServer.logger.warn("Could not map severity for #{severity} - returning 2")
+        2
+      end
+    end
+
+    def diagnostics(text, filename = nil)
+      return initialization_offenses unless @initialization_error.nil?
+
+      maximum_severity = (ENV['LINT_LEVEL'] || 4).to_i
+      enabled_offenses = offenses(text, filename).reject { |offense| offense.status == :disabled }
+      enabled_offenses.map do |offense|
+        {
+          range: Location.position_hash(offense.location.line, offense.location.column, offense.location.last_line, offense.location.last_column),
+          severity: diagnostic_severity_for(offense.severity),
+          # code?: number | string;
+          code: 'code',
+          source: "RuboCop:#{offense.cop_name}",
+          message: offense.message
+        }
+      end.select { |hash| hash[:severity] <= maximum_severity }
+    end
+
+    private
+
+    def offenses(text, filename)
+      processed_source = RuboCop::ProcessedSource.new(text, 2.4, filename)
+      offenses = inspect_file(processed_source)
+      offenses.compact.flatten
+    end
+
+    def initialization_offenses
+      [
+        {
+          range: Location.position_hash(1, 1, 1, 1),
+          severity: 'startup', # diagnostic_severity_for(offense.severity),
+          # code?: number | string;
+          code: 'code',
+          source: 'RuboCop:RubyLanguageServer',
+          message: @initialization_error
+        }
+      ]
+    end
+  end
+end

data/lib/ruby_language_server/io.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RubyLanguageServer
+  class IO
+    def initialize(server)
+      @server = server
+      server.io = self
+      loop do
+        (id, response) = process_request(STDIN)
+        return_response(id, response, STDOUT) unless id.nil?
+      rescue SignalException => e
+        RubyLanguageServer.logger.error "We received a signal.  Let's bail: #{e}"
+        exit(true)
+      rescue Exception => e
+        RubyLanguageServer.logger.error "Something when horribly wrong: #{e}"
+        backtrace = e.backtrace * "\n"
+        RubyLanguageServer.logger.error "Backtrace:\n#{backtrace}"
+      end
+    end
+
+    def return_response(id, response, io = STDOUT)
+      full_response = {
+        jsonrpc: '2.0',
+        id: id,
+        result: response
+      }
+      response_body = JSON.unparse(full_response)
+      # RubyLanguageServer.logger.debug "response_body: #{response_body}"
+      io.write "Content-Length: #{response_body.length + 0}\r\n"
+      io.write "\r\n"
+      io.write response_body
+      io.flush
+    end
+
+    def send_notification(message, params, io = STDOUT)
+      full_response = {
+        jsonrpc: '2.0',
+        method: message,
+        params: params
+      }
+      body = JSON.unparse(full_response)
+      # RubyLanguageServer.logger.debug "body: #{body}"
+      io.write "Content-Length: #{body.length + 0}\r\n"
+      io.write "\r\n"
+      io.write body
+      io.flush
+    end
+
+    def process_request(io = STDIN)
+      request_body = get_request(io)
+      # RubyLanguageServer.logger.debug "request_body: #{request_body}"
+      request_json = JSON.parse request_body
+      id = request_json['id']
+      method_name = request_json['method']
+      params = request_json['params']
+      method_name = "on_#{method_name.gsub(/[^\w]/, '_')}"
+      if @server.respond_to? method_name
+        response = @server.send(method_name, params)
+        exit(true) if response == 'EXIT'
+        return id, response
+      else
+        RubyLanguageServer.logger.warn "SERVER DOES NOT RESPOND TO #{method_name}"
+        return nil
+      end
+    end
+
+    def get_request(io = STDIN)
+      initial_line = get_initial_request_line(io)
+      RubyLanguageServer.logger.debug "initial_line: #{initial_line}"
+      length = get_length(initial_line)
+      content = ''
+      while content.length < length + 2
+        begin
+          content += get_content(length + 2, io) # Why + 2?  CRLF?
+        rescue Exception => exception
+          RubyLanguageServer.logger.error exception
+          # We have almost certainly been disconnected from the server
+          exit!(1)
+        end
+      end
+      RubyLanguageServer.logger.debug "content.length: #{content.length}"
+      content
+    end
+
+    def get_initial_request_line(io = STDIN)
+      io.gets
+    end
+
+    def get_length(string)
+      return 0 if string.nil?
+
+      string.match(/Content-Length: (\d+)/)[1].to_i
+    end
+
+    def get_content(size, io = STDIN)
+      io.read(size)
+    end
+
+    # http://www.alecjacobson.com/weblog/?p=75
+    # def stdin_read_char
+    #   begin
+    #     # save previous state of stty
+    #     old_state = `stty -g`
+    #     # disable echoing and enable raw (not having to press enter)
+    #     system "stty raw -echo"
+    #     c = STDIN.getc.chr
+    #     # gather next two characters of special keys
+    #     if(c=="\e")
+    #       extra_thread = Thread.new{
+    #         c = c + STDIN.getc.chr
+    #         c = c + STDIN.getc.chr
+    #       }
+    #       # wait just long enough for special keys to get swallowed
+    #       extra_thread.join(0.00001)
+    #       # kill thread so not-so-long special keys don't wait on getc
+    #       extra_thread.kill
+    #     end
+    #   rescue Exception => ex
+    #     puts "#{ex.class}: #{ex.message}"
+    #     puts ex.backtrace
+    #   ensure
+    #     # restore previous state of stty
+    #     system "stty #{old_state}"
+    #   end
+    #   return c
+    # end
+  end # class
+end # module

data/lib/ruby_language_server/line_context.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# The purpose of this class is to parse a single line and return an array of the
+# context words given the position of the cursor.
+
+# FooModule::BarModule.method_name.ivar = some_var.some_method
+#                        ^
+# ['FooModule', 'BarModule', 'method_name']
+#                                             ^
+# ['some_var']
+
+# If the first part of the context is :: then it returns a leading nil in the array
+
+# ::FooModule
+#     ^
+# [nil, 'FooModule']
+
+module RubyLanguageServer
+  module LineContext
+    def self.for(line, position)
+      # Grab just the last part of the line - from the index onward
+      line_end = line[position..-1]
+      return nil if line_end.nil?
+
+      # Grab the portion of the word that starts at the position toward the end of the line
+      match = line_end.partition(/^(@{0,2}\w+)/)[1]
+      RubyLanguageServer.logger.debug("match: #{match}")
+      # Get the start of the line to the end of the matched word
+      line_start = line[0..(position + match.length - 1)]
+      RubyLanguageServer.logger.debug("line_start: #{line_start}")
+      # Match as much as we can to the end of the line - which is now the end of the word
+      end_match = line_start.partition(/(@{0,2}[:\.\w]+)$/)[1]
+      matches = end_match.split('.', -1)
+      matches = matches.map { |m| m.length.positive? ? m.split('::', -1) : m }.flatten
+      RubyLanguageServer.logger.debug("matches: #{matches}")
+      matches
+    end
+  end
+end

data/lib/ruby_language_server/location.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  # Hash factories for the language server
+  module Location
+    def self.hash(uri, start_line, start_character = 1, end_line = nil, end_character = nil)
+      {
+        uri: uri,
+        range: position_hash(start_line, start_character, end_line, end_character)
+      }
+    end
+
+    def self.position_hash(start_line, start_character = 1, end_line = nil, end_character = nil)
+      end_line ||= start_line
+      end_character ||= start_character
+      {
+        start:
+        {
+          line: start_line - 1,
+          character: start_character
+        },
+        'end': {
+          line: end_line - 1,
+          character: end_character
+        }
+      }
+    end
+  end
+end

data/lib/ruby_language_server/logger.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module RubyLanguageServer
+  level_name = ENV.fetch('LOG_LEVEL') { 'info' }.upcase
+  # level_name = 'DEBUG'
+  level = Logger::Severity.const_get(level_name)
+  @logger = ::Logger.new(STDERR, level: level)
+
+  def self.logger
+    @logger
+  end
+end

data/lib/ruby_language_server/project_manager.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require 'fuzzy_match'
+require 'amatch' # note that you have to require this... fuzzy_match won't require it for you
+FuzzyMatch.engine = :amatch # This should be in a config somewhere
+
+module RubyLanguageServer
+  class ProjectManager
+    attr_reader :uri_code_file_hash
+
+    def initialize(uri)
+      @root_path = uri
+      @root_uri = "file://#{@root_path}"
+      # This is {uri: code_file} where content stuff is like
+      @uri_code_file_hash = {}
+      @update_mutext = Mutex.new
+
+      @additional_gems_installed = false
+      @additional_gem_mutex = Mutex.new
+
+      scan_all_project_files
+    end
+
+    def diagnostics_ready?
+      @additional_gem_mutex.synchronize { @additional_gems_installed }
+    end
+
+    def install_additional_gems(gem_names)
+      Thread.new do
+        RubyLanguageServer::GemInstaller.install_gems(gem_names)
+        @additional_gem_mutex.synchronize { @additional_gems_installed = true }
+      end
+    end
+
+    def text_for_uri(uri)
+      code_file = code_file_for_uri(uri)
+      code_file&.text || ''
+    end
+
+    def code_file_for_uri(uri, text = nil)
+      code_file = @uri_code_file_hash[uri]
+      code_file = @uri_code_file_hash[uri] = CodeFile.new(uri, text) if code_file.nil?
+      code_file
+    end
+
+    def tags_for_uri(uri)
+      code_file = code_file_for_uri(uri)
+      return {} if code_file.nil?
+
+      code_file.tags
+    end
+
+    def root_scope_for(uri)
+      code_file = code_file_for_uri(uri)
+      RubyLanguageServer.logger.error('code_file.nil?!!!!!!!!!!!!!!') if code_file.nil?
+      code_file&.root_scope
+    end
+
+    def all_scopes
+      @uri_code_file_hash.values.map(&:root_scope).map(&:self_and_descendants).flatten
+    end
+
+    # Return the list of scopes [deepest, parent, ..., Object]
+    def scopes_at(uri, position)
+      root_scope = root_scope_for(uri)
+      root_scope.scopes_at(position)
+    end
+
+    def completion_at(uri, position)
+      relative_position = position.dup
+      relative_position.character = relative_position.character # To get before the . or ::
+      # RubyLanguageServer.logger.debug("relative_position #{relative_position}")
+      RubyLanguageServer.logger.debug("scopes_at(uri, position) #{scopes_at(uri, position).map(&:name)}")
+      context_scope = scopes_at(uri, position).first || root_scope_for(uri)
+      context = context_at_location(uri, relative_position)
+      return {} if context.nil? || context == ''
+
+      RubyLanguageServer::Completion.completion(context, context_scope, all_scopes)
+    end
+
+    # interface CompletionItem {
+    #   /**
+    #    * The label of this completion item. By default
+    #    * also the text that is inserted when selecting
+    #    * this completion.
+    #    */
+    #   label: string;
+    #   /**
+    #    * The kind of this completion item. Based of the kind
+    #    * an icon is chosen by the editor.
+    #    */
+    #   kind?: number;
+    #   /**
+    #    * A human-readable string with additional information
+    #    * about this item, like type or symbol information.
+    #    */
+    #   detail?: string;
+    #   /**
+    #    * A human-readable string that represents a doc-comment.
+    #    */
+    #   documentation?: string;
+    #   /**
+    #    * A string that shoud be used when comparing this item
+    #    * with other items. When `falsy` the label is used.
+    #    */
+    #   sortText?: string;
+    #   /**
+    #    * A string that should be used when filtering a set of
+    #    * completion items. When `falsy` the label is used.
+    #    */
+    #   filterText?: string;
+    #   /**
+    #    * A string that should be inserted a document when selecting
+    #    * this completion. When `falsy` the label is used.
+    #    */
+    #   insertText?: string;
+    #   /**
+    #    * The format of the insert text. The format applies to both the `insertText` property
+    #    * and the `newText` property of a provided `textEdit`.
+    #    */
+    #   insertTextFormat?: InsertTextFormat;
+    #   /**
+    #    * An edit which is applied to a document when selecting this completion. When an edit is provided the value of
+    #    * `insertText` is ignored.
+    #    *
+    #    * *Note:* The range of the edit must be a single line range and it must contain the position at which completion
+    #    * has been requested.
+    #    */
+    #   textEdit?: TextEdit;
+    #   /**
+    #    * An optional array of additional text edits that are applied when
+    #    * selecting this completion. Edits must not overlap with the main edit
+    #    * nor with themselves.
+    #    */
+    #   additionalTextEdits?: TextEdit[];
+    #   /**
+    #    * An optional set of characters that when pressed while this completion is active will accept it first and
+    #    * then type that character. *Note* that all commit characters should have `length=1` and that superfluous
+    #    * characters will be ignored.
+    #    */
+    #   commitCharacters?: string[];
+    #   /**
+    #    * An optional command that is executed *after* inserting this completion. *Note* that
+    #    * additional modifications to the current document should be described with the
+    #    * additionalTextEdits-property.
+    #    */
+    #   command?: Command;
+    #   /**
+    #    * An data entry field that is preserved on a completion item between
+    #    * a completion and a completion resolve request.
+    #    */
+    #   data?: any
+    # }
+
+    def scan_all_project_files
+      project_ruby_files = Dir.glob('/project/**/*.rb')
+      RubyLanguageServer.logger.debug("scan_all_project_files: #{project_ruby_files * ','}")
+      Thread.new do
+        project_ruby_files.each do |container_path|
+          text = File.read(container_path)
+          relative_path = container_path.delete_prefix('/project/')
+          host_uri = @root_uri + relative_path
+          update_document_content(host_uri, text)
+        end
+      end
+    end
+
+    def update_document_content(uri, text)
+      @update_mutext.synchronize do
+        RubyLanguageServer.logger.debug("update_document_content: #{uri}")
+        # RubyLanguageServer.logger.error("@root_path: #{@root_path}")
+        code_file = code_file_for_uri(uri, text)
+        code_file.text = text
+        diagnostics_ready? ? code_file.diagnostics : []
+      end
+    end
+
+    def context_at_location(uri, position)
+      lines = text_for_uri(uri).split("\n")
+      line = lines[position.line]
+      return [] if line.nil? || line.strip.length.zero?
+
+      contexts = LineContext.for(line, position.character)
+      RubyLanguageServer.logger.debug("LineContext.for(line, position.character): #{contexts}")
+      contexts
+    end
+
+    def word_at_location(uri, position)
+      context_at_location(uri, position).last
+    end
+
+    def possible_definitions(uri, position)
+      name = word_at_location(uri, position)
+      return {} if name == ''
+
+      name = 'initialize' if name == 'new'
+      scope = scopes_at(uri, position).first
+      results = scope_definitions_for(name, scope, uri)
+      return results unless results.empty?
+
+      project_definitions_for(name, scope)
+    end
+
+    def scope_definitions_for(name, scope, uri)
+      check_scope = scope
+      return_array = []
+      while check_scope
+        scope.variables.each do |variable|
+          return_array << Location.hash(uri, variable.line) if variable.name == name
+        end
+        check_scope = check_scope.parent
+      end
+      RubyLanguageServer.logger.debug("scope_definitions_for(#{name}, #{scope}, #{uri}: #{return_array.uniq})")
+      return_array.uniq
+    end
+
+    def project_definitions_for(name, _scope)
+      return_array = @uri_code_file_hash.keys.each_with_object([]) do |uri, ary|
+        tags = tags_for_uri(uri)
+        RubyLanguageServer.logger.debug("tags_for_uri(#{uri}): #{tags_for_uri(uri)}")
+        next if tags.nil?
+
+        match_tags = tags.select { |tag| tag[:name] == name }
+        match_tags.each do |tag|
+          ary << Location.hash(uri, tag[:location][:range][:start][:line] + 1)
+        end
+      end
+      return_array
+    end
+  end
+end

data/lib/ruby_language_server/scope_data/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module ScopeData
+    class Base
+      TYPE_MODULE = :module
+      TYPE_CLASS = :class
+      TYPE_METHOD = :method
+      TYPE_BLOCK = :block
+      TYPE_ROOT = :root
+      TYPE_VARIABLE = :variable
+
+      JoinHash = {
+        TYPE_MODULE => '::',
+        TYPE_CLASS => '::',
+        TYPE_METHOD => '#',
+        TYPE_BLOCK => '>',
+        TYPE_ROOT => '',
+        TYPE_VARIABLE => '^'
+      }.freeze
+    end
+  end
+end

data/lib/ruby_language_server/scope_data/scope.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module ScopeData
+    # The Scope class is basically a container with context.
+    # It is used to track top & bottom line, variables in this scope, contanst, and children - which could be functions, classes, blocks, etc.  Anything that adds scope.
+    # Remember, this is scope for a file.  It seems reasonabble that this will get used less in the future when we know more about classes.
+    class Scope < Base
+      include Enumerable
+
+      attr_accessor :top_line        # first line
+      attr_accessor :bottom_line     # last line
+      attr_accessor :depth           # how many parent scopes
+      attr_accessor :parent          # parent scope
+      attr_accessor :variables       # variables declared in this scope
+      attr_accessor :constants       # constants declared in this scope
+      attr_accessor :children        # child scopes
+      attr_accessor :type            # Type of this scope (module, class, block)
+      attr_accessor :name            # method
+      attr_accessor :superclass_name # superclass name
+
+      def initialize(parent = nil, type = TYPE_ROOT, name = '', top_line = 1, _column = 1)
+        super()
+        @parent = parent
+        @type = type
+        @name = name
+        @top_line = top_line
+        @depth = parent.nil? ? 0 : parent.depth + 1
+        @full_name = [parent ? parent.full_name : nil, @name].compact.join(JoinHash[type]) unless type == TYPE_ROOT
+        @children = []
+        @variables = []
+        @constants = []
+      end
+
+      def inspect
+        "Scope: #{@name} (#{@full_name}) #{@top_line}-#{@bottom_line} children: #{@children} vars: #{@variables}"
+      end
+
+      def pretty_print(pp) # rubocop:disable Naming/UncommunicativeMethodParamName
+        {
+          Scope: {
+            type: type,
+            name: name,
+            lines: [@top_line, @bottom_line],
+            children: children,
+            variables: variables
+          }
+        }.pretty_print(pp)
+      end
+
+      def full_name
+        @full_name || @name
+      end
+
+      def has_variable_or_constant?(variable) # rubocop:disable Naming/PredicateName
+        test_array = variable.constant? ? constants : variables
+        matching_variable = test_array.detect { |test_variable| (test_variable.name == variable.name) }
+        !matching_variable.nil?
+      end
+
+      # Return the deepest child scopes of this scope - and on up.
+      # Not done recuresively because we don't really need to.
+      # Normally called on a root scope.
+      def scopes_at(position)
+        line = position.line
+        matching_scopes = select do |scope|
+          scope.top_line && scope.bottom_line && (scope.top_line..scope.bottom_line).cover?(line)
+        end
+        return [] if matching_scopes == []
+
+        deepest_scope = matching_scopes.max_by(&:depth)
+        deepest_scope.self_and_ancestors
+      end
+
+      def each
+        self_and_descendants.each { |member| yield member }
+      end
+
+      # Self and all descendents flattened into array
+      def self_and_descendants
+        [self] + descendants
+      end
+
+      def descendants
+        children.map(&:self_and_descendants).flatten
+      end
+
+      # [self, parent, parent.parent...]
+      def self_and_ancestors
+        return [self, parent.self_and_ancestors].flatten unless parent.nil?
+
+        [self]
+      end
+
+      def set_superclass_name(partial)
+        if partial.start_with?('::')
+          @superclass_name = partial.gsub(/^::/, '')
+        else
+          @superclass_name = [parent ? parent.full_name : nil, partial].compact.join(JoinHash[type])
+        end
+      end
+    end
+  end
+end