ruby_language_server 0.2.10 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10cb4b4c269544056f69b47cd3ffa4bfe55eeb2637e9d8a47279c8a13e34bb7d
-  data.tar.gz: b17613ed4c17e3fc62cc04623ece8ca442568ae54d3843cdad1adf630521e8bc
+  metadata.gz: 020e4ff18a466c0ca90d360610148699d96e9d983f173499169fe79923c0b201
+  data.tar.gz: abc71a6aa28296af4c53404a74500690e339a9c7b27c563b8699bfedcb0f16fd
 SHA512:
-  metadata.gz: a1d40873acea7759a42cc18408c1f7783266359820772c6ba3b34c46789caca9513da83ffd568206a3d77a3a5b36fc6bdf799ae43acb829049cdfa9ac5c50afb
-  data.tar.gz: 494d757d57eae4824f1b1be25756a033000a75baab0ed0d3dfa3c892ea49c85225f6b9c3ce37ba1258b9cb245d70ac83e8b754ff8cafa0bff1a13e5c05e4e104
+  metadata.gz: 441a9f0fad64e0fef21268bc7b4e78ad7c3d966d1b690a53af404c27ae063238c94dca7455eb8ebb1b259d8aec2e3f409cfac28b83973427866f6da3e1e1e00f
+  data.tar.gz: 8010f23f8fd7f24cb2a9e3883fdf86cd9c9401720a005bdef97a8537844edc44b14a311dcca19937c18076efebb454093eed11947cdc4409b37bb7be578ff16c

data/CHANGELOG.txt

@@ -1,5 +1,11 @@
 # Changelog
 
+#### 0.3.0 Tue Aug 20 17:23:38 PDT 2019
+
+* #33 - migrate to database
+** add sqlite
+** add ActiveRecord
+
 #### 0.2.10 Mon Aug  5 22:34:54 PDT 2019
 
 * #41 - Rubocop version mismatch

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    ruby_language_server (0.2.10)
+    ruby_language_server (0.3.0)
+      activerecord
       amatch
       bundler
       etc
@@ -9,16 +10,30 @@ PATH
       json
       rubocop
       rubocop-rspec
+      sqlite3
 
 GEM
   remote: https://rubygems.org/
   specs:
+    activemodel (5.2.3)
+      activesupport (= 5.2.3)
+    activerecord (5.2.3)
+      activemodel (= 5.2.3)
+      activesupport (= 5.2.3)
+      arel (>= 9.0)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
     amatch (0.4.0)
       mize
       tins (~> 1.0)
+    arel (9.0.0)
     ast (2.4.0)
     byebug (11.0.1)
     coderay (1.1.2)
+    concurrent-ruby (1.1.5)
     etc (1.0.1)
     ffi (1.11.1)
     formatador (0.2.5)
@@ -39,6 +54,8 @@ GEM
     guard-rubocop (1.3.0)
       guard (~> 2.0)
       rubocop (~> 0.20)
+    i18n (1.6.0)
+      concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.3)
     json (2.2.0)
     listen (3.1.5)
@@ -87,8 +104,12 @@ GEM
       sexp_processor (~> 4.9)
     sexp_processor (4.12.1)
     shellany (0.0.1)
+    sqlite3 (1.4.1)
     thor (0.20.3)
+    thread_safe (0.3.6)
     tins (1.21.1)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
     unicode-display_width (1.6.0)
 
 PLATFORMS

data/Makefile

@@ -5,9 +5,12 @@ build:
 	docker build -t $(PROJECT_NAME) .
 
 guard: build
-	docker run -it $(LOCAL_LINK) $(PROJECT_NAME) bundle exec guard
+	echo > active_record.log
+	docker run -it --rm $(LOCAL_LINK) -e LOG_LEVEL=DEBUG $(PROJECT_NAME) bundle exec guard
+	echo > active_record.log
 
 continuous_development: build
+	docker build -t local_ruby_language_server .
 	echo "You are going to want to set the ide-ruby 'Image Name' to local_ruby_language_server"
 	sleep 15
 	while (true) ; \

data/README.md

@@ -50,7 +50,7 @@ Write tests and guard will run them.  Make changes and reload the window.  Test
 
 * For for release
 * bump version in version.rb file and Gemfile.lock
-* change log
+* [CHANGELOG.txt](CHANGELOG.txt)
 * make gem_release
 
 # Authors

data/exe/ruby_language_server

@@ -5,5 +5,5 @@ $LOAD_PATH << File.join(__dir__, '..', 'lib')
 
 require 'ruby_language_server'
 
-server = RubyLanguageServer::Server.new
-RubyLanguageServer::IO.new(server)
+application = RubyLanguageServer::Application.new
+application.start

data/lib/config/initializers/active_record.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: 'file::memory:?cache=shared',
+  # database: '/database',
+  pool: 5, # does not seem to help
+  checkout_timeout: 30.seconds # does not seem to help
+)
+
+if ENV['LOG_LEVEL'] == 'DEBUG'
+  begin
+    warn('Turning on active record logging')
+    ActiveRecord::Base.logger = Logger.new(File.open('active_record.log', 'w'))
+  rescue Exception => e
+    ActiveRecord::Base.logger = Logger.new(STDERR)
+    ActiveRecord::Base.logger.error(e)
+  end
+end

data/lib/config/initializers/sqlite.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'sqlite3'

data/lib/db/schema.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define do
+  def write(*args)
+    RubyLanguageServer.logger.debug(args)
+  end
+
+  create_table :scopes, force: true do |t|
+    t.references :code_file
+    t.integer :parent_id
+    t.integer :top_line        # first line
+    t.integer :bottom_line     # last line
+    t.integer :column
+    t.string  :name, default: ''
+    t.string  :superclass_name
+    t.string  :path
+    t.string  :class_type, null: false
+  end
+
+  add_index :scopes, :name
+  add_index :scopes, :path
+  add_index :scopes, :code_file
+
+  create_table :variables, force: true do |t|
+    t.references :code_file
+    t.references :scope
+    t.integer :line
+    t.integer :column
+    t.string  :name
+    t.string  :path
+    t.string  :variable_type
+  end
+
+  add_index :variables, :name
+  add_index :variables, :code_file
+
+  create_table :code_files, force: true do |t|
+    t.string  :uri
+    t.boolean :refresh_root_scope, default: true
+    t.text    :text
+  end
+
+  add_index :code_files, :uri
+end

data/lib/ruby_language_server.rb

@@ -1,14 +1,3 @@
 # 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'
+require_relative 'ruby_language_server/application'

data/lib/ruby_language_server/application.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'active_record'
+
+require_relative 'logger' # do this first!
+require_relative '../config/initializers/sqlite'
+require_relative '../config/initializers/active_record'
+require_relative '../db/schema'
+
+require_relative 'version'
+require_relative 'gem_installer'
+require_relative 'io'
+require_relative 'location'
+require_relative 'code_file'
+require_relative 'scope_parser'
+require_relative 'good_cop'
+require_relative 'project_manager'
+require_relative 'server'
+require_relative 'line_context'
+require_relative 'completion'
+
+module RubyLanguageServer
+  class Application
+    def start
+      update_mutex = Monitor.new
+      server = RubyLanguageServer::Server.new(update_mutex)
+      RubyLanguageServer::IO.new(server, update_mutex)
+    end
+  end
+end

data/lib/ruby_language_server/code_file.rb

@@ -1,32 +1,40 @@
 # frozen_string_literal: true
 
+require 'active_record'
+
 require_relative 'scope_data/base'
 require_relative 'scope_data/scope'
 require_relative 'scope_data/variable'
 
 module RubyLanguageServer
-  class CodeFile
-    attr_reader :uri
-    attr_reader :text
+  class CodeFile < ActiveRecord::Base
+    has_many :scopes, class_name: 'RubyLanguageServer::ScopeData::Scope', dependent: :destroy do
+      def root_scope
+        where(class_type: RubyLanguageServer::ScopeData::Scope::TYPE_ROOT).first
+      end
+    end
+    has_many :variables, class_name: 'RubyLanguageServer::ScopeData::Variable', dependent: :destroy
+
     attr_accessor :diagnostics
 
-    def initialize(uri, text)
+    def self.build(uri, text)
       RubyLanguageServer.logger.debug("CodeFile initialize #{uri}")
-      @uri = uri
-      @text = text
-      @refresh_root_scope = true
-    end
 
-    def text=(new_text)
-      RubyLanguageServer.logger.debug("text= for #{uri}")
-      if @text == new_text
-        RubyLanguageServer.logger.debug('IT WAS THE SAME!!!!!!!!!!!!')
-        return
-      end
-      @text = new_text
-      @refresh_root_scope = true
+      new_code_file = create!(uri: uri, text: text)
+      new_code_file
     end
 
+    # def text=(new_text)
+    #   RubyLanguageServer.logger.debug("text= for #{uri}")
+    #   if @text == new_text
+    #     RubyLanguageServer.logger.debug('IT WAS THE SAME!!!!!!!!!!!!')
+    #     return
+    #   end
+    #   @text = new_text
+    #   update_attribute(:refresh_root_scope, true)
+    #   root_scope
+    # end
+    #
     SYMBOL_KIND = {
       file: 1,
       'module': 5, # 2,
@@ -53,46 +61,44 @@ module RubyLanguageServer
     def ancestor_scope_name(scope)
       return_scope = scope
       while (return_scope = return_scope.parent)
-        return return_scope.name unless return_scope.name.nil?
+        return return_scope.name unless return_scope.name.nil? || return_scope.block_scope?
       end
     end
 
     def tags
       RubyLanguageServer.logger.debug("Asking about tags for #{uri}")
-      return @tags = {} if text.nil? || text == ''
+      @tags ||= [{}]
+      return @tags if text.nil?
+      return @tags = [{}] if text == ''
+
+      refresh_scopes_if_needed # cause root scope to reset
+      return @tags if scopes.reload.count <= 1 # just the root
 
-      tags = []
-      root_scope.self_and_descendants.each do |scope|
-        next if scope.type == ScopeData::Base::TYPE_BLOCK
+      tags = scopes.reload.map do |scope|
+        next if scope.class_type == ScopeData::Base::TYPE_BLOCK
+        next if scope.root_scope?
 
-        name = scope.name
-        kind = SYMBOL_KIND[scope.type] || 7
-        kind = 9 if name == 'initialize' # Magical special case
+        kind = SYMBOL_KIND[scope.class_type.to_sym] || 7
+        kind = 9 if scope.name == 'initialize' # Magical special case
         scope_hash = {
-          name: name,
+          name: scope.name,
           kind: kind,
           location: Location.hash(uri, scope.top_line)
         }
         container_name = ancestor_scope_name(scope)
-        scope_hash[:containerName] = container_name if container_name
-        tags << scope_hash
-
-        scope.variables.each do |variable|
-          name = variable.name
-          # We only care about counstants
-          next unless name =~ /^[A-Z]/
-
-          variable_hash = {
-            name: name,
-            kind: SYMBOL_KIND[:constant],
-            location: Location.hash(uri, variable.line),
-            containerName: scope.name
-          }
-          tags << variable_hash
-        end
+        scope_hash[:containerName] = container_name unless container_name.blank?
+        scope_hash
       end
-      # byebug
-      tags.reject! { |tag| tag[:name].nil? }
+      tags += variables.constant_variables.reload.map do |variable|
+        name = variable.name
+        {
+          name: name,
+          kind: SYMBOL_KIND[:constant],
+          location: Location.hash(uri, variable.line - 1),
+          containerName: variable.scope.name
+        }
+      end
+      tags = tags.compact.reject { |tag| tag[:name].nil? || tag[:name] == RubyLanguageServer::ScopeData::Scope::TYPE_BLOCK }
       # RubyLanguageServer.logger.debug("Raw tags for #{uri}: #{tags}")
       # If you don't reverse the list then atom? won't be able to find the
       # container and containers will get duplicated.
@@ -106,18 +112,32 @@ module RubyLanguageServer
       @tags
     end
 
-    def root_scope
-      # RubyLanguageServer.logger.error("Asking about root_scope with #{text}")
-      if @refresh_root_scope
-        new_root_scope = ScopeParser.new(text).root_scope
-        @root_scope ||= new_root_scope # In case we had NONE
-        return @root_scope if new_root_scope.children.empty?
+    def update_text(new_text)
+      RubyLanguageServer.logger.debug("update_text for #{uri}")
+      return true if new_text == text
+
+      RubyLanguageServer.logger.debug('Changed!')
+      update(text: new_text, refresh_root_scope: true)
+    end
+
+    def refresh_scopes_if_needed
+      return unless refresh_root_scope
 
-        @root_scope = new_root_scope
-        @refresh_root_scope = false
-        @tags = nil
+      RubyLanguageServer.logger.debug("Asking about root_scope for #{uri}")
+      RubyLanguageServer::ScopeData::Variable.where(code_file_id: self).scoping do
+        RubyLanguageServer::ScopeData::Scope.where(code_file_id: self).scoping do
+          self.class.transaction do
+            scopes.clear
+            variables.clear
+            new_root = ScopeParser.new(text).root_scope
+            RubyLanguageServer.logger.debug("new_root.children #{new_root.children.as_json}") if new_root&.children
+            raise ActiveRecord::Rollback if new_root.nil? || new_root.children.blank?
+
+            update_attribute(:refresh_root_scope, false)
+            new_root
+          end
+        end
       end
-      @root_scope
     end
 
     # Returns the context of what is being typed in the given line

data/lib/ruby_language_server/completion.rb

@@ -25,10 +25,10 @@ module RubyLanguageServer
 
     class << self
       def completion(context, context_scope, scopes)
-        RubyLanguageServer.logger.debug("completion(#{context}, #{context_scope.self_and_ancestors.map(&:name)}, #{scopes.map(&:name)})")
+        RubyLanguageServer.logger.debug("completion(#{context}, #{scopes.map(&:name)})")
         completions =
           if context.length < 2
-            scope_completions(context.last, context_scope.self_and_ancestors)
+            scope_completions(context.last, scopes)
           else
             scope_completions_in_target_context(context, context_scope, scopes)
           end
@@ -44,12 +44,13 @@ module RubyLanguageServer
       end
 
       def scope_with_name(name, scopes)
+        return scopes.where(name: name).first if scopes.respond_to?(:where)
+
         scopes.detect { |scope| scope.name == name }
       end
 
       def scope_completions_in_target_context(context, context_scope, scopes)
-        working_array = context.dup
-        context_word = working_array[-2]
+        context_word = context[-2]
         if context_word.match?(/^[A-Z]/)
           scope = scope_with_name(context_word, scopes)
         else
@@ -59,22 +60,22 @@ module RubyLanguageServer
         end
         scope ||= context_scope
         RubyLanguageServer.logger.debug("scope: #{scope}")
-        scope_completions(context.last, scope.self_and_ancestors)
+        scope_completions(context.last, [scope] + scopes.includes(:variables))
       end
 
       def scope_completions(word, scopes)
         words = {}
         scopes.each_with_object(words) do |scope, words_hash|
-          scope.children.select(&:'method?').each do |method_scope|
+          scope.children.method_scopes.each do |method_scope|
             words_hash[method_scope.name] ||= {
               depth: scope.depth,
-              type: method_scope.type
+              type: method_scope.class_type
             }
           end
           scope.variables.each do |variable|
             words_hash[variable.name] ||= {
               depth: scope.depth,
-              type: variable.type
+              type: variable.variable_type
             }
           end
         end

data/lib/ruby_language_server/io.rb

@@ -4,8 +4,9 @@ require 'json'
 
 module RubyLanguageServer
   class IO
-    def initialize(server)
+    def initialize(server, mutex)
       @server = server
+      @mutex = mutex
       server.io = self
       loop do
         (id, response) = process_request(STDIN)
@@ -57,7 +58,11 @@ module RubyLanguageServer
       params = request_json['params']
       method_name = "on_#{method_name.gsub(/[^\w]/, '_')}"
       if @server.respond_to? method_name
-        response = @server.send(method_name, params)
+        RubyLanguageServer.logger.debug 'Locking io'
+        response = @mutex.synchronize do
+          @server.send(method_name, params)
+        end
+        RubyLanguageServer.logger.debug 'UNLocking io'
         exit(true) if response == 'EXIT'
         return id, response
       else

data/lib/ruby_language_server/location.rb

@@ -3,14 +3,14 @@
 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)
+    def self.hash(uri, start_line, start_character = 0, 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)
+    def self.position_hash(start_line, start_character = 0, end_line = nil, end_character = nil)
       end_line ||= start_line
       end_character ||= start_character
       {

data/lib/ruby_language_server/project_manager.rb

@@ -49,13 +49,8 @@ module RubyLanguageServer
 
       @root_uri = "file://#{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?
@@ -90,13 +85,14 @@ module RubyLanguageServer
     end
 
     def all_scopes
-      @uri_code_file_hash.values.map(&:root_scope).map(&:self_and_descendants).flatten
+      RubyLanguageServer::ScopeData::Scope.all
     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)
+      code_file = code_file_for_uri(uri)
+      code_file.refresh_scopes_if_needed
+      code_file.scopes.for_line(position.line).where.not(path: nil).by_path_length
     end
 
     def completion_at(uri, position)
@@ -104,11 +100,12 @@ module RubyLanguageServer
       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)
+      position_scopes = scopes_at(uri, position) || RubyLanguageServer::ScopeData::Scope.where(id: root_scope_for(uri).id)
+      context_scope = position_scopes.first
       context = context_at_location(uri, relative_position)
       return {} if context.nil? || context == ''
 
-      RubyLanguageServer::Completion.completion(context, context_scope, all_scopes)
+      RubyLanguageServer::Completion.completion(context, context_scope, position_scopes)
     end
 
     # interface CompletionItem {
@@ -185,29 +182,37 @@ module RubyLanguageServer
     #   data?: any
     # }
 
-    def scan_all_project_files
+    def scan_all_project_files(mutex)
       project_ruby_files = Dir.glob("#{self.class.root_path}**/*.rb")
       Thread.new do
+        RubyLanguageServer.logger.error('Threading up!')
         project_ruby_files.each do |container_path|
+          # Let's not preload spec/test or vendor - yet..
+          next if container_path.match?(/^(.?spec|test|vendor)/)
+
           text = File.read(container_path)
           relative_path = container_path.delete_prefix(self.class.root_path)
           host_uri = @root_uri + relative_path
-          update_document_content(host_uri, text)
+          RubyLanguageServer.logger.debug "Locking scan for #{container_path}"
+          mutex.synchronize do
+            RubyLanguageServer.logger.debug("Threading #{host_uri}")
+            update_document_content(host_uri, text)
+            code_file_for_uri(host_uri).refresh_scopes_if_needed
+          end
+          RubyLanguageServer.logger.debug "Unlocking scan for #{container_path}"
         end
       end
     end
 
     # returns diagnostic info (if possible)
     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)
-        return code_file.diagnostics if code_file.text == text
-
-        code_file.text = text
-        diagnostics_ready? ? updated_diagnostics_for_codefile(code_file) : []
-      end
+      RubyLanguageServer.logger.debug("update_document_content: #{uri}")
+      # RubyLanguageServer.logger.error("@root_path: #{@root_path}")
+      code_file = code_file_for_uri(uri)
+      return code_file.diagnostics if code_file.text == text
+
+      code_file.update_text(text)
+      diagnostics_ready? ? updated_diagnostics_for_codefile(code_file) : []
     end
 
     def updated_diagnostics_for_codefile(code_file)
@@ -224,19 +229,19 @@ module RubyLanguageServer
     end
 
     def word_at_location(uri, position)
-      context_at_location(uri, position).last
+      context_at_location(uri, position)&.last
     end
 
     def possible_definitions(uri, position)
       name = word_at_location(uri, position)
-      return {} if name == ''
+      return {} if name.blank?
 
       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)
+      project_definitions_for(name)
     end
 
     def scope_definitions_for(name, scope, uri)
@@ -244,7 +249,7 @@ module RubyLanguageServer
       return_array = []
       while check_scope
         scope.variables.each do |variable|
-          return_array << Location.hash(uri, variable.line) if variable.name == name
+          return_array << Location.hash(uri.delete_prefix(self.class.root_uri), variable.line - 1) if variable.name == name
         end
         check_scope = check_scope.parent
       end
@@ -252,25 +257,18 @@ module RubyLanguageServer
       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
+    def project_definitions_for(name)
+      scopes = RubyLanguageServer::ScopeData::Scope.where(name: name)
+      variables = RubyLanguageServer::ScopeData::Variable.constant_variables.where(name: name)
+      (scopes + variables).map do |thing|
+        Location.hash(thing.code_file.uri.delete_prefix(self.class.root_uri), thing.top_line)
       end
-      return_array
     end
 
     private
 
     def code_file_for_uri(uri)
-      code_file = @uri_code_file_hash[uri]
-      code_file = @uri_code_file_hash[uri] = CodeFile.new(uri, nil) if code_file.nil?
+      code_file = CodeFile.find_by_uri(uri) || CodeFile.build(uri, nil)
       code_file
     end
 

data/lib/ruby_language_server/scope_data/base.rb

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
+require 'active_record'
+
 module RubyLanguageServer
   module ScopeData
-    class Base
-      TYPE_MODULE = :module
-      TYPE_CLASS = :class
-      TYPE_METHOD = :method
-      TYPE_BLOCK = :block
-      TYPE_ROOT = :root
-      TYPE_VARIABLE = :variable
+    class Base < ActiveRecord::Base
+      self.abstract_class = true
+
+      TYPE_MODULE = 'module'
+      TYPE_CLASS = 'class'
+      TYPE_METHOD = 'method'
+      TYPE_BLOCK = 'block'
+      TYPE_ROOT = 'root'
+      TYPE_VARIABLE = 'variable'
+
+      BLOCK_NAME = 'block'
 
       JoinHash = {
         TYPE_MODULE => '::',

data/lib/ruby_language_server/scope_data/scope.rb

@@ -1,103 +1,103 @@
 # frozen_string_literal: true
 
+require 'active_record'
+
 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, constants, and children - which could be functions, classes, blocks, etc.  Anything that adds scope.
     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 :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
-        if type == TYPE_ROOT
-          @full_name = nil
-        else
-          @full_name = [parent ? parent.full_name : nil, @name].compact.join(JoinHash[type])
-        end
-        @children = []
-        @variables = []
-        @constants = []
-      end
+      has_many :variables, dependent: :destroy
+      belongs_to :code_file
+      belongs_to :parent, class_name: 'Scope', optional: true
+      has_many :children, class_name: 'Scope', foreign_key: :parent_id
 
-      def inspect
-        "Scope: #{@name} (#{@full_name} - #{@type}) #{@top_line}-#{@bottom_line} children: #{@children} vars: #{@variables}"
-      end
+      scope :method_scopes, -> { where(class_type: TYPE_METHOD) }
+      scope :for_line, ->(line) { where('top_line <= ? AND bottom_line >= ?', line, line).or(where(parent_id: nil)) }
+      scope :by_path_length, -> { order('length(path) DESC') }
+      # attr_accessor :top_line        # first line
+      # attr_accessor :bottom_line     # last line
+      # attr_accessor :parent          # parent scope
+      # attr_accessor :constants       # constants declared in this scope
+      # attr_accessor :name            # method
+      # attr_accessor :superclass_name # superclass name
 
-      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)
+      def self.build(parent = nil, type = TYPE_ROOT, name = '', top_line = 1, column = 1)
+        full_name = [parent ? parent.full_name : nil, name].compact.join(JoinHash[type])
+        create!(
+          parent: parent,
+          top_line: top_line,
+          column: column,
+          name: name,
+          path: full_name,
+          class_type: type
+        )
       end
 
       def full_name
-        @full_name || @name
+        path # @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?
+      def depth
+        return 0 if path.blank?
+
+        scope_parts.count
       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
+      # def scopes_at(position)
+      #   line = position.line
+      #   matching_scopes = self_and_descendants.where('top_line <= ?', line).where('bottom_line >= ?', line)
+      #   deepest_scope = matching_scopes.max_by(&:depth)
+      #   deepest_scope&.self_and_ancestors || []
+      # end
 
       # Self and all descendents flattened into array
       def self_and_descendants
-        [self] + descendants
+        return Scope.all if root_scope?
+
+        Scope.where('path like ?', "#{path}%")
       end
 
       def descendants
-        children.map(&:self_and_descendants).flatten
+        Scope.where('path like ?', "#{path}_%")
       end
 
       # [self, parent, parent.parent...]
-      def self_and_ancestors
-        [self, parent&.self_and_ancestors].flatten.compact
-      end
+      # def self_and_ancestors
+      #   return [self] if path.blank?
+      #   remaining_path = path.dup
+      #   ancestor_paths = scope_parts.inject([]) do |ary, scope_part|
+      #     ary << remaining_path
+      #     remaining_path =
+      #     ary
+      #   end
+      #   [self, parent&.self_and_ancestors].flatten.compact
+      # end
 
       def set_superclass_name(partial)
         if partial.start_with?('::')
-          @superclass_name = partial.gsub(/^::/, '')
+          self.superclass_name = partial.gsub(/^::/, '')
         else
-          @superclass_name = [parent ? parent.full_name : nil, partial].compact.join(JoinHash[type])
+          self.superclass_name = [parent ? parent.full_name : nil, partial].compact.join(JoinHash[class_type])
         end
+        save!
+      end
+
+      def root_scope?
+        class_type == TYPE_ROOT
+      end
+
+      def block_scope?
+        class_type == TYPE_BLOCK
+      end
+
+      private
+
+      def scope_parts
+        path&.split(/#{JoinHash.values.reject(&:blank?).uniq.join('|')}/)
       end
     end
   end

data/lib/ruby_language_server/scope_data/variable.rb

@@ -1,24 +1,44 @@
 # frozen_string_literal: true
 
+require 'active_record'
+
 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
+      belongs_to :code_file
+      belongs_to :scope
+
+      scope :constant_variables, -> { where("SUBSTR(name, 1, 1) between ('A') and ('Z')") }
+
+      # attr_accessor :line            # line
+      # attr_accessor :column          # column
+      # attr_accessor :name            # name
+      # attr_accessor :path            # Module::Class name
 
-      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
-        raise "bogus variable #{inspect}" unless @name.instance_of? String
+      def self.build(scope, name, line = 1, column = 1, type = TYPE_VARIABLE)
+        path = [scope.full_name, name].join(JoinHash[TYPE_VARIABLE])
+        create!(
+          line: line,
+          column: column,
+          name: name,
+          path: path,
+          variable_type: type
+        )
+        # @name = name
+        # @line = line
+        # @column = column
+        # @full_name =
+        # @type = type
+        # raise "bogus variable #{inspect}" unless @name.instance_of? String
       end
 
       def constant?
-        !@name&.match(/^[A-Z]/).nil?
+        !name&.match(/^[A-Z]/).nil?
+      end
+
+      # Convenience for tags
+      def top_line
+        line
       end
     end
   end

data/lib/ruby_language_server/scope_parser.rb

@@ -28,7 +28,7 @@ module RubyLanguageServer
     def root_scope
       return @root_scope unless @root_scope.nil?
 
-      @root_scope = new_root_scope
+      @root_scope = ScopeData::Scope.where(path: nil, class_type: ScopeData::Scope::TYPE_ROOT).first_or_create!
       @current_scope = @root_scope
       process(@sexp)
       @root_scope
@@ -117,13 +117,14 @@ module RubyLanguageServer
       # add_scope(args, rest, ScopeData::Scope::TYPE_BLOCK)
       unless @current_scope == scope
         scope.bottom_line = [scope&.bottom_line, @current_scope.bottom_line].compact.max
+        scope.save!
         pop_scope
       end
     end
 
     def on_do_block(args, rest)
       ((_, ((_, (_, (_, _name, (line, column))))))) = args
-      push_scope(ScopeData::Scope::TYPE_BLOCK, nil, line, column, false)
+      push_scope(ScopeData::Scope::TYPE_BLOCK, 'block', line, column, false)
       process(args)
       process(rest)
       pop_scope
@@ -268,17 +269,22 @@ module RubyLanguageServer
     private
 
     def add_variable(name, line, column, scope = @current_scope)
-      new_variable = ScopeData::Variable.new(scope, name, line, column)
-      # blocks don't declare their first line in the parser
-      scope.top_line ||= line
-      scope.variables << new_variable unless scope.has_variable_or_constant?(new_variable)
+      scope.variables.where(name: name).first_or_create(line: line, column: column)
+      if scope.top_line.blank?
+        scope.top_line = line
+        scope.save!
+      end
+      # new_variable = ScopeData::Variable.build(scope, name, line, column)
+      # # blocks don't declare their first line in the parser
+      # scope.top_line ||= line
+      # 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?
+        while !ivar_scope_types.include?(scope.class_type) && !scope.parent.nil?
           scope = scope.parent
         end
       end
@@ -299,20 +305,9 @@ module RubyLanguageServer
 
     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 = ScopeData::Scope.build(@current_scope, type, name, top_line, column)
       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
+      new_scope.save!
       @current_scope = new_scope
     end
 
@@ -320,19 +315,15 @@ module RubyLanguageServer
     # 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_scope&.descendants&.each { |scope| scope.bottom_line = [scope.bottom_line, line - 1].compact.min }
+      parent_scope&.descendants&.each do |scope|
+        scope.bottom_line = [scope.bottom_line, line - 1].compact.min
+        scope.save!
+      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.

data/lib/ruby_language_server/server.rb

@@ -7,11 +7,17 @@ module RubyLanguageServer
   class Server
     attr_accessor :io
 
+    def initialize(mutex)
+      @mutex = mutex
+    end
+
     def on_initialize(params)
       RubyLanguageServer.logger.info("on_initialize: #{params}")
+      RubyLanguageServer::CodeFile.all # Just to warm up active_record.
       root_path = params['rootPath']
       root_uri = params['rootUri']
       @project_manager = ProjectManager.new(root_path, root_uri)
+      @project_manager.scan_all_project_files(@mutex)
       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)

data/lib/ruby_language_server/version.rb

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

data/ruby_language_server.gemspec

@@ -45,6 +45,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'amatch'      # in c
   spec.add_dependency 'fuzzy_match' # completion matching
 
+  spec.add_dependency 'activerecord'
+  spec.add_dependency 'sqlite3'
+
   spec.add_development_dependency 'guard'
   spec.add_development_dependency 'guard-minitest'
   spec.add_development_dependency 'guard-rubocop'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_language_server
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.3.0
 platform: ruby
 authors:
 - Kurt Werle
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-06 00:00:00.000000000 Z
+date: 2019-08-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -256,8 +284,12 @@ files:
 - bin/console
 - bin/setup
 - exe/ruby_language_server
+- lib/config/initializers/active_record.rb
+- lib/config/initializers/sqlite.rb
+- lib/db/schema.rb
 - lib/resources/fallback_rubocop.yml
 - lib/ruby_language_server.rb
+- lib/ruby_language_server/application.rb
 - lib/ruby_language_server/code_file.rb
 - lib/ruby_language_server/completion.rb
 - lib/ruby_language_server/gem_installer.rb