ruby_language_server 0.2.0

data/lib/ruby_language_server/scope_data/variable.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module ScopeData
+    class Variable < Base
+      attr_accessor :line            # line
+      attr_accessor :column          # column
+      attr_accessor :name            # name
+      attr_accessor :full_name       # Module::Class name
+      attr_accessor :type            # type
+
+      def initialize(scope, name, line = 1, column = 1, type = TYPE_VARIABLE)
+        @name = name
+        @line = line
+        @column = column
+        @full_name = [scope.full_name, @name].join(JoinHash[TYPE_VARIABLE])
+        @type = type
+      end
+
+      def constant?
+        !@name&.match(/^[A-Z]/).nil?
+      end
+    end
+  end
+end

data/lib/ruby_language_server/scope_parser.rb

@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require 'ripper'
+require_relative 'scope_parser_commands/rake_commands'
+require_relative 'scope_parser_commands/rspec_commands'
+require_relative 'scope_parser_commands/ruby_commands'
+require_relative 'scope_parser_commands/rails_commands'
+
+module RubyLanguageServer
+  # This class is responsible for processing the generated sexp from the ScopeParser below.
+  # It builds scopes that amount to heirarchical arrays with information about what
+  # classes, methods, variables, etc - are in each scope.
+  class SEXPProcessor
+    include ScopeParserCommands::RakeCommands
+    include ScopeParserCommands::RspecCommands
+    include ScopeParserCommands::RailsCommands
+    include ScopeParserCommands::RubyCommands
+    attr_reader :sexp
+    attr_reader :lines
+    attr_reader :current_scope
+
+    def initialize(sexp, lines = 1)
+      @sexp = sexp
+      @lines = lines
+    end
+
+    def root_scope
+      return @root_scope unless @root_scope.nil?
+
+      @root_scope = new_root_scope
+      @current_scope = @root_scope
+      process(@sexp)
+      @root_scope
+    end
+
+    def process(sexp)
+      return if sexp.nil?
+
+      root, args, *rest = sexp
+      # RubyLanguageServer.logger.error("Doing #{[root, args, rest]}")
+      case root
+      when Array
+        sexp.each { |child| process(child) }
+      when Symbol
+        root = root.to_s.gsub(/^@+/, '')
+        method_name = "on_#{root}"
+        if respond_to? method_name
+          send(method_name, args, rest)
+        else
+          RubyLanguageServer.logger.debug("We don't have a #{method_name} with #{args}")
+          process(args)
+        end
+      when String
+        # We really don't do anything with it!
+        RubyLanguageServer.logger.debug("We don't do Strings like #{root} with #{args}")
+      when NilClass
+        process(args)
+      else
+        RubyLanguageServer.logger.warn("We don't respond to the likes of #{root} of class #{root.class}")
+      end
+    end
+
+    def on_sclass(_args, rest)
+      process(rest)
+    end
+
+    # foo = bar -- bar is in the vcall.  Pretty sure we don't want to remember this.
+    def on_vcall(_args, rest)
+      # Seriously - discard args.  Maybe process rest?
+      process(rest)
+    end
+
+    def on_program(args, _rest)
+      process(args)
+    end
+
+    def on_var_field(args, rest)
+      (_, name, (line, column)) = args
+      return if name.nil?
+
+      if name.start_with?('@')
+        add_ivar(name, line, column)
+      else
+        add_variable(name, line, column)
+      end
+      process(rest)
+    end
+
+    def on_bodystmt(args, _rest)
+      process(args)
+    end
+
+    def on_module(args, rest)
+      add_scope(args.last, rest, ScopeData::Scope::TYPE_MODULE)
+    end
+
+    def on_class(args, rest)
+      add_scope(args.last, rest, ScopeData::Scope::TYPE_CLASS)
+    end
+
+    def on_method_add_block(args, rest)
+      scope = @current_scope
+      process(args)
+      process(rest)
+      # add_scope(args, rest, ScopeData::Scope::TYPE_BLOCK)
+      unless @current_scope == scope
+        scope.bottom_line = [scope&.bottom_line, @current_scope.bottom_line].compact.max
+        pop_scope
+      end
+    end
+
+    def on_do_block(args, rest)
+      ((_, ((_, (_, (_, _name, (line, column))))))) = args
+      push_scope(ScopeData::Scope::TYPE_BLOCK, nil, line, column, false)
+      process(args)
+      process(rest)
+      pop_scope
+    end
+
+    # Used only to describe subclasses?
+    def on_var_ref(args, _)
+      # [:@const, "Bar", [13, 20]]
+      (_, name) = args
+      @current_scope.set_superclass_name(name)
+    end
+
+    def on_assign(args, rest)
+      process(args)
+      process(rest)
+    end
+
+    def on_def(args, rest)
+      add_scope(args, rest, ScopeData::Scope::TYPE_METHOD)
+    end
+
+    # def self.something(par)...
+    # [:var_ref, [:@kw, "self", [28, 14]]], [[:@period, ".", [28, 18]], [:@ident, "something", [28, 19]], [:paren, [:params, [[:@ident, "par", [28, 23]]], nil, nil, nil, nil, nil, nil]], [:bodystmt, [[:assign, [:var_field, [:@ident, "pax", [29, 12]]], [:var_ref, [:@ident, "par", [29, 18]]]]], nil, nil, nil]]
+    def on_defs(args, rest)
+      on_def(rest[1], rest[2]) if args[1][1] == 'self' && rest[0][1] == '.'
+    end
+
+    # ident is something that gets processed at parameters to a function or block
+    def on_ident(name, ((line, column)))
+      add_variable(name, line, column)
+    end
+
+    def on_params(args, rest)
+      process(args)
+      process(rest)
+    end
+
+    # The on_command function idea is stolen from RipperTags https://github.com/tmm1/ripper-tags/blob/master/lib/ripper-tags/parser.rb
+    def on_command(args, rest)
+      # [:@ident, "public", [6, 8]]
+      (_, name, (line, _column)) = args
+
+      method_name = "on_#{name}_command"
+      if respond_to? method_name
+        return send(method_name, line, args, rest)
+      else
+        RubyLanguageServer.logger.debug("We don't have a #{method_name} with #{args}")
+      end
+
+      case name
+      when 'public', 'private', 'protected'
+        # FIXME: access control...
+        process(rest)
+      when 'delegate'
+        # on_delegate(*args[0][1..-1])
+      when 'def_delegator', 'def_instance_delegator'
+        # on_def_delegator(*args[0][1..-1])
+      when 'def_delegators', 'def_instance_delegators'
+        # on_def_delegators(*args[0][1..-1])
+      end
+    end
+
+    # The on_method_add_arg function is downright stolen from RipperTags https://github.com/tmm1/ripper-tags/blob/master/lib/ripper-tags/parser.rb
+    def on_method_add_arg(call, args)
+      call_name = call && call[0]
+      first_arg = args && args[0] == :args && args[1]
+
+      if call_name == :call && first_arg
+        if args.length == 2
+          # augment call if a single argument was used
+          call = call.dup
+          call[3] = args[1]
+        end
+        call
+      elsif call_name == :fcall && first_arg
+        name, line = call[1]
+        case name
+        when 'alias_method' # this is an fcall
+          [:alias, args[1][0], args[2][0], line] if args[1] && args[2]
+        when 'define_method' # this is an fcall
+          [:def, args[1][0], line]
+        when 'public_class_method', 'private_class_method', 'private', 'public', 'protected'
+          access = name.sub('_class_method', '')
+
+          if args[1][1] == 'self'
+            klass = 'self'
+            method_name = args[1][2]
+          else
+            klass = nil
+            method_name = args[1][1]
+          end
+
+          [:def_with_access, klass, method_name, access, line]
+          # when 'scope', 'named_scope'
+          #   [:rails_def, :scope, args[1][0], line]
+          # when /^attr_(accessor|reader|writer)$/
+          #   gen_reader = Regexp.last_match(1) != 'writer'
+          #   gen_writer = Regexp.last_match(1) != 'reader'
+          #   args[1..-1].each_with_object([]) do |arg, gen|
+          #     gen << [:def, arg[0], line] if gen_reader
+          #     gen << [:def, "#{arg[0]}=", line] if gen_writer
+          #   end
+          # when 'has_many', 'has_and_belongs_to_many'
+          #   a = args[1][0]
+          #   kind = name.to_sym
+          #   gen = []
+          #   unless a.is_a?(Enumerable) && !a.is_a?(String)
+          #     a = a.to_s
+          #     gen << [:rails_def, kind, a, line]
+          #     gen << [:rails_def, kind, "#{a}=", line]
+          #     if (sing = a.chomp('s')) != a
+          #       # poor man's singularize
+          #       gen << [:rails_def, kind, "#{sing}_ids", line]
+          #       gen << [:rails_def, kind, "#{sing}_ids=", line]
+          #     end
+          #   end
+          #   gen
+          # when 'belongs_to', 'has_one'
+          #   a = args[1][0]
+          #   unless a.is_a?(Enumerable) && !a.is_a?(String)
+          #     kind = name.to_sym
+          #     %W[#{a} #{a}= build_#{a} create_#{a} create_#{a}!].inject([]) do |all, ident|
+          #       all << [:rails_def, kind, ident, line]
+          #     end
+          #   end
+        end
+      end
+    end
+
+    private
+
+    def add_variable(name, line, column, scope = @current_scope)
+      new_variable = ScopeData::Variable.new(scope, name, line, column)
+      scope.variables << new_variable unless scope.has_variable_or_constant?(new_variable)
+    end
+
+    def add_ivar(name, line, column)
+      scope = @current_scope
+      unless scope == root_scope
+        ivar_scope_types = [ScopeData::Base::TYPE_CLASS, ScopeData::Base::TYPE_MODULE]
+        while !ivar_scope_types.include?(scope.type) && !scope.parent.nil?
+          scope = scope.parent
+        end
+      end
+      add_variable(name, line, column, scope)
+    end
+
+    def add_scope(args, rest, type)
+      (_, name, (line, column)) = args
+      push_scope(type, name, line, column)
+      process(rest)
+      pop_scope
+    end
+
+    def type_is_class_or_module(type)
+      [RubyLanguageServer::ScopeData::Base::TYPE_CLASS, RubyLanguageServer::ScopeData::Base::TYPE_MODULE].include?(type)
+    end
+
+    def push_scope(type, name, top_line, column, close_siblings = true)
+      close_sibling_scopes(top_line) if close_siblings
+      # The default root scope is Object.  Which is fine if we're adding methods.
+      # But if we're adding a class, we don't care that it's in Object.
+      new_scope =
+        if (type_is_class_or_module(type) && (@current_scope == root_scope))
+          ScopeData::Scope.new(nil, type, name, top_line, column)
+        else
+          ScopeData::Scope.new(@current_scope, type, name, top_line, column)
+        end
+      new_scope.bottom_line = @lines
+      if new_scope.parent.nil? # was it a class or module at the root
+        root_scope.children << new_scope
+      else
+        @current_scope.children << new_scope
+      end
+      @current_scope = new_scope
+    end
+
+    # This is a very poor man's "end" handler because there is no end handler.
+    # The notion is that when you start the next scope, all the previous peers and unclosed descendents of the previous peer should be closed.
+    def close_sibling_scopes(line)
+      parent_scope = @current_scope.parent
+      unless parent_scope.nil?
+        last_sibling = parent_scope.children.last
+        until last_sibling.nil?
+          last_sibling.bottom_line = line - 1
+          last_sibling = last_sibling.children.last
+        end
+      end
+    end
+
+    def pop_scope
+      @current_scope = @current_scope.parent || root_scope # in case we are leaving a root class/module
+    end
+
+    def new_root_scope
+      ScopeData::Scope.new.tap do |scope|
+        scope.type = ScopeData::Scope::TYPE_ROOT
+        scope.name = nil
+      end
+    end
+  end
+
+  # This class builds on Ripper's sexp processor to add ruby and rails magic.
+  # Specifically it knows about things like alias, attr_*, has_one/many, etc.
+  # It adds the appropriate definitions for those magic words.
+  class ScopeParser < Ripper
+    attr_reader :root_scope
+
+    def initialize(text)
+      text ||= '' # empty is the same as nil - but it doesn't crash
+      begin
+        sexp = self.class.sexp(text)
+      rescue TypeError => exception
+        RubyLanguageServer.logger.error("Exception in sexp: #{exception} for text: #{text}")
+      end
+      processor = SEXPProcessor.new(sexp, text.length)
+      @root_scope = processor.root_scope
+    end
+  end
+end

data/lib/ruby_language_server/scope_parser_commands/rails_commands.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module ScopeParserCommands
+    module RailsCommands
+      def rails_add_reference(line, args, rest)
+        # args: [:@ident, "has_one", [2, 2]]
+        # rest: [[:args_add_block, [[:symbol_literal, [:symbol, [:@ident, "bar", [2, 11]]]]], false]]
+
+        # Looks like the first string is gonna be the name
+        (_, _, (_, column)) = args
+        name = rest.flatten.detect { |o| o.instance_of? String }
+        [name, "#{name}="].each do |method_name|
+          push_scope(RubyLanguageServer::ScopeData::Base::TYPE_METHOD, method_name, line, column)
+          process(rest)
+          pop_scope
+        end
+      end
+
+      alias on_has_one_command                 rails_add_reference
+      alias on_has_many_command                rails_add_reference
+      alias on_belongs_to_command              rails_add_reference
+      alias on_has_and_belongs_to_many_command rails_add_reference
+      alias on_scope_command                   rails_add_reference
+      alias on_named_scope_command             rails_add_reference
+      # alias on_ xxx _command rails_add_reference
+    end
+  end
+end

data/lib/ruby_language_server/scope_parser_commands/rake_commands.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module ScopeParserCommands
+    module RakeCommands
+      def on_task_command(line, args, rest)
+        # OMG.  Rake commands can have like any form.
+        # The most reliable way I can see to name them is to grab the string
+        # I *so* do not want to hear about it when it doesn't work.
+        name = rest.flatten.detect { |o| o.instance_of?(String) }
+        # add_scope(args, rest, ScopeData::Scope::TYPE_METHOD)
+        push_scope(ScopeData::Scope::TYPE_MODULE, name, line, 0, false)
+        process(args)
+        process(rest)
+        # We push a scope and don't pop it because we're called inside on_method_add_block
+      end
+
+      def on_namespace_command(line, args, rest)
+        # OMG.  Rake commands can have like any form.
+        # The most reliable way I can see to name them is to grab the string
+        # I *so* do not want to hear about it when it doesn't work.
+        name = rest.flatten.detect { |o| o.instance_of?(String) }
+        # add_scope(args, rest, ScopeData::Scope::TYPE_METHOD)
+        push_scope(ScopeData::Scope::TYPE_MODULE, name, line, 0, false)
+        process(args)
+        process(rest)
+        # We push a scope and don't pop it because we're called inside on_method_add_block
+      end
+    end
+  end
+end

data/lib/ruby_language_server/scope_parser_commands/readme.txt

@@ -0,0 +1,9 @@
+There are various ruby and rails DSLs that are so common it makes sense to add
+support for them.  Things like
+attr_reader :foo
+it 'should do something' do ...
+describe 'some thing' do ...
+task something: ... do ...
+
+Eventually maybe it will make sense to add these things using gems.  For now,
+just dump it in.

data/lib/ruby_language_server/scope_parser_commands/rspec_commands.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module ScopeParserCommands
+    module RspecCommands
+      def on_describe_command(line, args, rest)
+        rspec_block_command('describe', line, args, rest)
+      end
+
+      def on_it_command(line, args, rest)
+        rspec_block_command('it', line, args, rest)
+      end
+
+      private
+
+      def rspec_block_command(prefix, line, args, rest)
+        name = "#{prefix} "
+        name += rest.flatten.select { |part| part.instance_of?(String) }.join('::')
+        push_scope(ScopeData::Scope::TYPE_MODULE, name, line, 0, false)
+        process(args)
+        process(rest)
+        # We push a scope and don't pop it because we're called inside on_method_add_block
+      end
+    end
+  end
+end

data/lib/ruby_language_server/scope_parser_commands/ruby_commands.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  module ScopeParserCommands
+    module RubyCommands
+      # when 'define_method', 'alias_method',
+      #      'public_class_method', 'private_class_method',
+      #      # "public", "protected", "private",
+      #      /^attr_(accessor|reader|writer)$/
+      #   # on_method_add_arg([:fcall, name], args[0])
+      # when 'attr'
+      #   # [[:args_add_block, [[:symbol_literal, [:symbol, [:@ident, "top", [3, 14]]]]], false]]
+      #   ((_, ((_, (_, (_, name, (line, column))))))) = rest
+      #   add_ivar("@#{name}", line, column)
+      #   push_scope(ScopeData::Scope::TYPE_METHOD, name, line, column)
+      #   pop_scope
+      #   push_scope(ScopeData::Scope::TYPE_METHOD, "#{name}=", line, column)
+      #   pop_scope
+
+      def on_attr_command(line, args, rest)
+        column = ruby_command_column(args)
+        names = ruby_command_names(rest)
+        ruby_command_add_attr(line, column, names, true, true)
+      end
+
+      def on_attr_accessor_command(line, args, rest)
+        column = ruby_command_column(args)
+        names = ruby_command_names(rest)
+        ruby_command_add_attr(line, column, names, true, true)
+      end
+
+      def on_attr_reader_command(line, args, rest)
+        column = ruby_command_column(args)
+        names = ruby_command_names(rest)
+        ruby_command_add_attr(line, column, names, true, false)
+      end
+
+      def on_attr_writer_command(line, args, rest)
+        column = ruby_command_column(args)
+        names = ruby_command_names(rest)
+        ruby_command_add_attr(line, column, names, false, true)
+      end
+
+      private
+
+      def ruby_command_names(rest)
+        names = rest.flatten.select { |o| o.instance_of? String }
+        names
+      end
+
+      def ruby_command_column(args)
+        (_, _, (_, column)) = args
+        column
+      end
+
+      def ruby_command_add_attr(line, column, names, reader, writer)
+        names.each do |name|
+          if reader
+            push_scope(RubyLanguageServer::ScopeData::Base::TYPE_METHOD, name, line, column)
+            pop_scope
+          end
+          if writer
+            push_scope(RubyLanguageServer::ScopeData::Base::TYPE_METHOD, "#{name}=", line, column)
+            pop_scope
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_language_server/server.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# Deal with the various languageserver calls.
+module RubyLanguageServer
+  class Server
+    attr_accessor :io
+
+    def on_initialize(params)
+      RubyLanguageServer.logger.info("on_initialize: #{params}")
+      root_path = params['rootPath']
+      @project_manager = ProjectManager.new(root_path)
+      gem_string = ENV.fetch('ADDITIONAL_GEMS') {}
+      gem_array = (gem_string.split(',').compact.map(&:strip).reject { |string| string == '' } if gem_string && !gem_string.empty?)
+      @project_manager.install_additional_gems(gem_array)
+      {
+        capabilities: {
+          textDocumentSync: 1,
+          hoverProvider: true,
+          signatureHelpProvider: {
+            triggerCharacters: ['(', ',']
+          },
+          definitionProvider: true,
+          referencesProvider: true,
+          documentSymbolProvider: true,
+          workspaceSymbolProvider: true,
+          xworkspaceReferencesProvider: true,
+          xdefinitionProvider: true,
+          xdependenciesProvider: true,
+          completionProvider: {
+            resolveProvider: true,
+            triggerCharacters: ['.', '::']
+          },
+          codeActionProvider: true,
+          renameProvider: true,
+          executeCommandProvider: {
+            commands: []
+          },
+          xpackagesProvider: true
+        }
+      }
+    end
+
+    def on_workspace_didChangeWatchedFiles(params)
+      RubyLanguageServer.logger.debug('on_workspace_didChangeWatchedFiles')
+      RubyLanguageServer.logger.debug(params)
+      {}
+    end
+
+    def on_textDocument_hover(params)
+      RubyLanguageServer.logger.debug('on_textDocument_hover')
+      RubyLanguageServer.logger.debug(params)
+      {}
+    end
+
+    def on_textDocument_documentSymbol(params)
+      RubyLanguageServer.logger.debug('on_textDocument_documentSymbol')
+      RubyLanguageServer.logger.debug(params)
+      uri = uri_from_params(params)
+
+      # {"kind":"module","line":4,"language":"Ruby","path":"(eval)","pattern":"module RubyLanguageServer","full_name":"RubyLanguageServer","name":"RubyLanguageServer"}
+      symbols = @project_manager.tags_for_uri(uri)
+      RubyLanguageServer.logger.debug("symbols #{symbols}")
+      symbols
+    end
+
+    def on_textDocument_definition(params)
+      RubyLanguageServer.logger.debug("on_textDocument_definition #{params}")
+      uri = uri_from_params(params)
+      position = postition_from_params(params)
+      @project_manager.possible_definitions(uri, position)
+    end
+
+    def send_diagnostics(uri, text)
+      hash = @project_manager.update_document_content(uri, text)
+      io.send_notification('textDocument/publishDiagnostics', uri: uri, diagnostics: hash)
+    end
+
+    def on_textDocument_didOpen(params)
+      textDocument = params['textDocument']
+      uri = textDocument['uri']
+      RubyLanguageServer.logger.debug("on_textDocument_didOpen #{uri}")
+      text = textDocument['text']
+      send_diagnostics(uri, text)
+    end
+
+    def on_textDocument_didChange(params)
+      uri = uri_from_params(params)
+      RubyLanguageServer.logger.debug("on_textDocument_didChange #{uri}")
+      content_changes = params['contentChanges']
+      text = content_changes.first['text']
+      send_diagnostics(uri, text)
+    end
+
+    def on_textDocument_completion(params)
+      RubyLanguageServer.logger.info("on_textDocument_completion #{params}")
+      uri = uri_from_params(params)
+      position = postition_from_params(params)
+      completions = @project_manager.completion_at(uri, position)
+      # RubyLanguageServer.logger.debug("completions: #{completions}")
+      completions
+    end
+
+    def on_shutdown(_params)
+      RubyLanguageServer.logger.info('on_shutdown')
+    end
+
+    private
+
+    def uri_from_params(params)
+      textDocument = params['textDocument']
+      textDocument['uri']
+    end
+
+    Position = Struct.new('Position', :line, :character)
+
+    def postition_from_params(params)
+      position = params['position']
+      Position.new((position['line']).to_i, position['character'].to_i)
+    end
+  end
+end

data/lib/ruby_language_server/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RubyLanguageServer
+  VERSION = '0.2.0'
+end

data/lib/ruby_language_server.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'ruby_language_server/logger' # do this first!
+require_relative 'ruby_language_server/version'
+require_relative 'ruby_language_server/gem_installer'
+require_relative 'ruby_language_server/io'
+require_relative 'ruby_language_server/location'
+require_relative 'ruby_language_server/code_file'
+require_relative 'ruby_language_server/scope_parser'
+require_relative 'ruby_language_server/good_cop'
+require_relative 'ruby_language_server/project_manager'
+require_relative 'ruby_language_server/server'
+require_relative 'ruby_language_server/line_context'
+require_relative 'ruby_language_server/completion'