holistic-ruby 0.1.1 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 601bd799099f6615186f5d70dafab227a2f5d59e556aedec607784fc289b9f23
-  data.tar.gz: 8684f179e1cf58b47d4cac81c75c10113c46f5578a9ab1ecd74eddcad2e20259
+  metadata.gz: 43d41e307a4ae8b8b904fda778342ef5d175db25580697f597f606f3aa2a0173
+  data.tar.gz: 5286406cf4e0f5a5cb21745b3f7d49268eb934e4002e76d1ba43f9dfdda034fd
 SHA512:
-  metadata.gz: 6cc033aaddc4b86f6b733c17c7cea974fabcc68132b7f7776dcbe9bdf4f6222ed52d6e58694e9988d624b693eab3d6abcf28389d5208b41221fee511e33c486e
-  data.tar.gz: 54ebf824ec6771d1b58146a6c958a9271e229daa5c2d0c3a23830a873be8ffc523065f06a0240d821256712dd2c31c7136a7bf6e38fb7552eab4124bec24b5c8
+  metadata.gz: 882cac6ec7c32d309898aab43f001a3fcf0e497b6c019569472db3880b792e95fe50158b8672690c80237e0a9c6ac361ede5b79a09e2784ddc944d103c54eaba
+  data.tar.gz: 64e1becad926aba30e7c9f25b294a2ff9b53dcdfe7affc5e59792054cf21b17b3509eb7fc80e1819fecc9f7d7e22957df3bda2c03990b9e77476c3bc1fa956e0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    holistic-ruby (0.1.0)
+    holistic-ruby (0.1.4)
       activesupport (~> 7.0)
       syntax_tree (~> 6.0)
       zeitwerk (~> 2.6)

data/README.md

@@ -32,4 +32,4 @@
 
 ## Why is it a toy language server?
 
-I use `holistic-ruby` on a daily basis in a faily large Ruby codebase. It seems stable and speedy. But... I built it for myself and I'm the only one using it :smile:
+I use `holistic-ruby` on a daily basis while working in a fairly large Ruby codebase. It seems stable and speedy. But... I built it for myself and I'm the only one using it :smile:

data/lib/holistic/application.rb

@@ -2,12 +2,12 @@
 
 module Holistic
   class Application
-    attr_reader :name, :root_directory, :root_scope
+    attr_reader :name, :root_directory, :database
 
     def initialize(name:, root_directory:)
       @name = name
       @root_directory = root_directory
-      @root_scope = Ruby::Scope::Record.new(kind: Ruby::Scope::Kind::ROOT, name: "::", parent: nil)
+      @database = Database::Table.new.tap(&Database::Migrations::Run)
     end
 
     def extensions
@@ -15,11 +15,19 @@ module Holistic
     end
 
     def scopes
-      @scopes ||= Ruby::Scope::Repository.new
+      @scopes ||= Ruby::Scope::Repository.new(database:)
     end
 
     def references
-      @references ||= Ruby::Reference::Repository.new
+      @references ||= Ruby::Reference::Repository.new(database:)
+    end
+
+    def files
+      @files ||= Document::File::Repository.new(database:)
+    end
+
+    def type_inference_processing_queue
+      @type_inference_processing_queue ||= Ruby::TypeInference::ProcessingQueue.new
     end
 
     def unsaved_documents

data/lib/holistic/database/migrations.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Holistic::Database::Migrations
+  Run = ->(database) do
+    # scope parent-children relation
+    database.define_connection(name: :children, inverse_of: :parent)
+
+    # type inference conclusion
+    database.define_connection(name: :referenced_scope, inverse_of: :referenced_by)
+
+    # reference definition
+    database.define_connection(name: :located_in_scope, inverse_of: :contains_many_references)
+
+    # scope location in files
+    database.define_connection(name: :defines_scopes, inverse_of: :scope_defined_in_file)
+
+    # reference location in files
+    database.define_connection(name: :defines_references, inverse_of: :reference_defined_in_file)
+  end
+end

data/lib/holistic/database/node.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Holistic::Database
+  class Node
+    attr_accessor :attributes, :connections, :__database__
+
+    def initialize(id, attributes)
+      @id = id
+      @attributes = attributes
+      @connections = ::Hash.new { |hash, key| hash[key] = ::Set.new }
+    end
+
+    def attr(attribute_name)
+      @attributes[attribute_name]
+    end
+
+    def has_many(connection_name)
+      @connections[connection_name].to_a
+    end
+
+    def has_one(connection_name)
+      @connections[connection_name].first
+    end
+
+    def __set_database__(database)
+      @__database__ = database
+    end
+  end
+end

data/lib/holistic/database/table.rb

@@ -1,78 +1,78 @@
-# frozen_string_literal: true
-
-class Holistic::Database::Table
-  attr_reader :primary_attribute, :primary_index, :secondary_indices
-
-  def initialize(primary_attribute:, indices: [])
-    @primary_attribute = primary_attribute
 
-    @primary_index = ::Hash.new
+# frozen_string_literal: true
 
-    @secondary_indices = indices.map do |attribute_name|
-      [attribute_name, ::Hash.new { |hash, key| hash[key] = ::Set.new }]
-    end.to_h
-  end
+module Holistic::Database
+  class Table
+    attr_reader :records, :connections
 
-  RecordNotUniqueError = ::Class.new(::StandardError)
+    def initialize
+      @records = ::Hash.new
+      @connections = ::Hash.new
+    end
 
-  def insert(record)
-    primary_key = record.fetch(primary_attribute)
+    def define_connection(name:, inverse_of:)
+      raise ::ArgumentError if @connections.key?(name) || @connections.key?(inverse_of)
 
-    if primary_index.key?(primary_key)
-      raise RecordNotUniqueError, "record already inserted: #{record.inspect}"
+      @connections[name] = { inverse_of: }
+      @connections[inverse_of] = { inverse_of: name }
     end
 
-    primary_index[primary_key] = record
-
-    secondary_indices.each do |attribute_name, secondary_index|
-      Array(record[attribute_name]).each do |value|
-        secondary_index[value].add(primary_key)
+    def store(id, node_or_attrs)
+      if @records.key?(id)
+        return @records[id]&.tap do |node|
+          node.attributes =
+            case node_or_attrs
+            in ::Hash then node_or_attrs
+            in Node   then node_or_attrs.attributes
+            end
+        end
       end
-    end
-  end
 
-  def find(identifier)
-    primary_index[identifier]
-  end
+      node =
+        case node_or_attrs
+        in ::Hash then Node.new(id, node_or_attrs)
+        in Node   then node_or_attrs
+        end
 
-  def filter(name, value)
-    return [] unless secondary_indices[name].key?(value)
+      node.__set_database__(self)
 
-    secondary_indices.dig(name, value).to_a.map { find(_1) }
-  end
-
-  def update(record)
-    primary_key = record.fetch(primary_attribute)
+      @records[id] = node
+    end
 
-    delete(primary_key)
+    def connect(source:, target:, name:, inverse_of:)
+      connection = @connections[name]
 
-    insert(record)
-  end
+      raise ::ArgumentError if connection.nil? || connection[:inverse_of] != inverse_of
 
-  def delete(primary_key)
-    record = find(primary_key)
+      source.connections[name].add(target)
+      target.connections[inverse_of].add(source)
+    end
 
-    return if record.nil?
+    def disconnect(source:, target:, name:, inverse_of:)
+      connection = @connections[name]
 
-    primary_index.delete(primary_key)
+      raise ::ArgumentError if connection.nil? || connection[:inverse_of] != inverse_of
 
-    secondary_indices.each do |attribute_name, index_data|
-      Array(record[attribute_name]).each do |value|
-        index_data[value].delete(primary_key)
-        index_data.delete(value) if index_data[value].empty?
-      end
+      source.connections[name].delete(target)
+      target.connections[inverse_of].delete(source)
     end
 
-    record
-  end
+    def find(id)
+      @records[id]
+    end
 
-  concerning :TestHelpers do
-    def all
-      primary_index.values
+    def delete(id)
+      records.delete(id)
     end
 
-    def size
-      primary_index.size
+    concerning :TestHelpers do
+      def all
+        records.values
+      end
+
+      def size
+        records.size
+      end
     end
   end
 end

data/lib/holistic/document/file/record.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Holistic::Document::File
+  class Record < ::Holistic::Database::Node
+    def path = attr(:path)
+
+    def defines_scopes     = has_many(:defines_scopes)
+    def defines_references = has_many(:defines_references)
+  end
+end

data/lib/holistic/document/file/repository.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ::Holistic::Document::File
+  class Repository
+    attr_reader :database
+
+    def initialize(database:)
+      @database = database
+    end
+
+    # rename to `find_file`
+    def find(file_path)
+      @database.find(file_path)
+    end
+
+    concerning :TestHelpers do
+      def build_fake_location(file_path)
+        file = Store.call(database:, file_path:)
+
+        ::Holistic::Document::Location.new(file, 0, 0, 0, 0)
+      end
+    end
+  end
+end

data/lib/holistic/document/file/store.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Holistic::Document::File
+  module Store
+    extend self
+
+    def call(database:, file_path:)
+      record = Record.new(file_path, { path: file_path })
+
+      database.store(file_path, record)
+    end
+  end
+end

data/lib/holistic/document/location.rb

@@ -2,20 +2,18 @@
 
 module Holistic::Document
   Location = ::Data.define(
-    :file_path,
+    :file,
     :start_line,
     :start_column,
     :end_line,
     :end_column
   ) do
-    def self.beginning_of_file(file_path)
-      new(file_path, 0, 0, 0, 0)
+    def identifier
+      "#{file.path}[#{start_line},#{start_column},#{end_line},#{end_column}]"
     end
 
-    def identifier = "#{file_path}[#{start_line},#{start_column},#{end_line},#{end_column}]"
-
     def contains?(cursor)
-      same_file = cursor.file_path == file_path
+      same_file = cursor.file_path == file.path
       contains_line = cursor.line >= start_line && cursor.line <= end_line
       
       contains_column =

data/lib/holistic/document/unsaved/record.rb

@@ -75,9 +75,5 @@ module Holistic::Document
         end
       end
     end
-
-    def to_file
-      File::Fake.new(path:, content:)
-    end
   end
 end

data/lib/holistic/extensions/events.rb

@@ -5,6 +5,14 @@ class Holistic::Extensions::Events
     resolve_method_call_known_scope: {
       params: [:reference, :referenced_scope, :method_call_clue],
       output: ::Holistic::Ruby::Scope::Record
+    },
+    class_scope_registered: {
+      params: [:class_scope, :location],
+      output: nil
+    },
+    lambda_scope_registered: {
+      params: [:lambda_scope, :location],
+      output: nil
     }
   }.freeze
 
@@ -30,7 +38,7 @@ class Holistic::Extensions::Events
 
     result = @listeners[event].lazy.filter_map { |callback| callback.call(params) }.first
 
-    raise UnexpectedOutput, result if result.present? && !result.is_a?(expected_output)
+    raise UnexpectedOutput, result if expected_output.present? && result.present? && !result.is_a?(expected_output)
 
     result
   end

data/lib/holistic/extensions/ruby/stdlib.rb

@@ -10,34 +10,48 @@ module Holistic::Extensions::Ruby
       if method_call_clue.method_name == "new" && referenced_scope.class?
         initialize_method = "#{referenced_scope.fully_qualified_name}#initialize"
 
-        return application.scopes.find_by_fully_qualified_name(initialize_method)
+        return application.scopes.find(initialize_method)
       end
 
       nil
     end
 
-    ResolveStaticMethods = ->(application, params) do
-      method_call_clue, referenced_scope = params[:method_call_clue], params[:referenced_scope]
+    RegisterClassConstructor = ->(application, params) do
+      class_scope, location = params[:class_scope], params[:location]
 
-      self_method_name = "#{referenced_scope.fully_qualified_name}#self.#{method_call_clue.method_name}"
+      has_overridden_new_method = class_scope.children.find { _1.instance_method? && _1.name == "initialize" }
 
-      application.scopes.find_by_fully_qualified_name(self_method_name)
+      unless has_overridden_new_method
+        ::Holistic::Ruby::Scope::Store.call(
+          database: application.database,
+          parent: class_scope,
+          kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
+          name: "new",
+          location:
+        )
+      end
     end
 
-    LAMBDA_METHODS = ["call", "curry"]
+    LAMBDA_METHODS = ["call", "curry"].freeze
 
-    ResolveCallToLambda = ->(application, params) do
-      method_call_clue, referenced_scope = params[:method_call_clue], params[:referenced_scope]
+    RegisterLambdaMethods = ->(application, params) do
+      lambda_scope, location = params[:lambda_scope], params[:location]
 
-      if LAMBDA_METHODS.include?(method_call_clue.method_name) && referenced_scope.lambda?
-        return referenced_scope
+      LAMBDA_METHODS.each do |method_name|
+        ::Holistic::Ruby::Scope::Store.call(
+          database: application.database,
+          parent: lambda_scope,
+          kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
+          name: method_name,
+          location:
+        )
       end
     end
 
     def register(application)
       application.extensions.bind(:resolve_method_call_known_scope, &ResolveClassConstructor.curry[application])
-      application.extensions.bind(:resolve_method_call_known_scope, &ResolveStaticMethods.curry[application])
-      application.extensions.bind(:resolve_method_call_known_scope, &ResolveCallToLambda.curry[application])
+      application.extensions.bind(:class_scope_registered,          &RegisterClassConstructor.curry[application])
+      application.extensions.bind(:lambda_scope_registered,         &RegisterLambdaMethods.curry[application])
     end
   end
 end

data/lib/holistic/language_server/requests/lifecycle/initialize.rb

@@ -14,23 +14,18 @@ module Holistic::LanguageServer
 
       parse_application_in_background(application)
 
-      respond_with_holistic_capabilities(request)
+      respond_with_language_server_capabilities(request)
     end
 
     private
 
     def create_application(request)
-      ::Holistic.logger.info("===========")
-      ::Holistic.logger.info(request.message.inspect)
-      
       root_directory = request.param("rootPath")
       name = ::File.basename(root_directory)
 
-      Current.application = ::Holistic::Application.new(name:, root_directory:)
-
-      ::Holistic::Extensions::Ruby::Stdlib.register(Current.application)
-
-      Current.application
+      Current.application = ::Holistic::Application.new(name:, root_directory:).tap do |application|
+        ::Holistic::Extensions::Ruby::Stdlib.register(application)
+      end
     end
 
     def advance_lifecycle_state
@@ -45,7 +40,7 @@ module Holistic::LanguageServer
       end
     end
 
-    def respond_with_holistic_capabilities(request)
+    def respond_with_language_server_capabilities(request)
       request.respond_with({
         capabilities: {
           # Defines how the host (editor) should sync document changes to the language server.

data/lib/holistic/language_server/requests/text_document/completion.rb

@@ -8,21 +8,23 @@ module Holistic::LanguageServer
       cursor = build_cursor_from_request_params(request)
 
       document = request.application.unsaved_documents.find(cursor.file_path)
-
+ 
       return request.respond_with(nil) if document.nil?
 
       if document.has_unsaved_changes?
         ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
           application: request.application,
-          file: document.to_file
+          file_path: document.path,
+          content: document.content
         )
       end
 
       code = document.expand_code(cursor)
-      scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.root_scope
 
       return request.respond_with(nil) if code.blank?
 
+      scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.scopes.root
+
       suggestions = ::Holistic::Ruby::Autocompletion::Suggest.call(code:, scope:)
 
       respond_with_suggestions(request, suggestions)
@@ -40,11 +42,12 @@ module Holistic::LanguageServer
 
     module CompletionKind
       FROM_SCOPE_TO_COMPLETION = {
-        ::Holistic::Ruby::Scope::Kind::CLASS  => Protocol::COMPLETION_ITEM_KIND_CLASS,
-        ::Holistic::Ruby::Scope::Kind::LAMBDA => Protocol::COMPLETION_ITEM_KIND_FUNCTION,
-        ::Holistic::Ruby::Scope::Kind::METHOD => Protocol::COMPLETION_ITEM_KIND_METHOD,
-        ::Holistic::Ruby::Scope::Kind::MODULE => Protocol::COMPLETION_ITEM_KIND_MODULE,
-        ::Holistic::Ruby::Scope::Kind::ROOT   => Protocol::COMPLETION_ITEM_KIND_MODULE
+        ::Holistic::Ruby::Scope::Kind::CLASS           => Protocol::COMPLETION_ITEM_KIND_CLASS,
+        ::Holistic::Ruby::Scope::Kind::LAMBDA          => Protocol::COMPLETION_ITEM_KIND_FUNCTION,
+        ::Holistic::Ruby::Scope::Kind::CLASS_METHOD    => Protocol::COMPLETION_ITEM_KIND_METHOD,
+        ::Holistic::Ruby::Scope::Kind::INSTANCE_METHOD => Protocol::COMPLETION_ITEM_KIND_METHOD,
+        ::Holistic::Ruby::Scope::Kind::MODULE          => Protocol::COMPLETION_ITEM_KIND_MODULE,
+        ::Holistic::Ruby::Scope::Kind::ROOT            => Protocol::COMPLETION_ITEM_KIND_MODULE
       }.freeze
 
       DEFAULT = Protocol::COMPLETION_ITEM_KIND_MODULE

data/lib/holistic/language_server/requests/text_document/did_close.rb

@@ -7,27 +7,21 @@ module Holistic::LanguageServer
     def call(request)
       path = Format::FileUri.extract_path(request.message.param("textDocument", "uri"))
 
-      unsaved_document = request.application.unsaved_documents.find(path)
-
-      if unsaved_document.present?
+      request.application.unsaved_documents.find(path)&.then do |unsaved_document|
         request.application.unsaved_documents.delete(path)
         
         if unsaved_document.has_unsaved_changes?
           unsaved_document.restore_original_content!
 
-          process_in_background(application: request.application, file: unsaved_document.to_file)
+          ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
+            application: request.application,
+            file_path: unsaved_document.path,
+            content: unsaved_document.content
+          )
         end
       end
 
       request.respond_with(nil)
     end
-
-    private
-
-    def process_in_background(application:, file:)
-      ::Holistic::BackgroundProcess.run do
-        ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(application:, file:)
-      end
-    end
   end
 end

data/lib/holistic/language_server/requests/text_document/did_open.rb

@@ -9,6 +9,7 @@ module Holistic::LanguageServer
       content = request.message.param("textDocument", "text")
 
       request.application.unsaved_documents.add(path:, content:)
+      ::Holistic::Document::File::Store.call(database: request.application.database, file_path: path)
 
       request.respond_with(nil)
     end

data/lib/holistic/language_server/requests/text_document/did_save.rb

@@ -17,17 +17,13 @@ module Holistic::LanguageServer
 
       unsaved_document.mark_as_saved!
 
-      process_in_background(application: request.application, file: unsaved_document.to_file)
+      ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
+        application: request.application,
+        file_path: unsaved_document.path,
+        content: unsaved_document.content
+      )
 
       request.respond_with(nil)
     end
-
-    private
-
-    def process_in_background(application:, file:)
-      ::Holistic::BackgroundProcess.run do
-        ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(application:, file:)
-      end
-    end
   end
 end

data/lib/holistic/language_server/requests/text_document/find_references.rb

@@ -12,7 +12,8 @@ module Holistic::LanguageServer
         if unsaved_document.has_unsaved_changes?
           ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
             application: request.application,
-            file: unsaved_document.to_file
+            file_path: unsaved_document.path,
+            content: unsaved_document.content
           )
         end
       end
@@ -37,11 +38,13 @@ module Holistic::LanguageServer
 
     def respond_with_locations(request, references)
       locations = references.map do |reference|
+        location = reference.location
+
         {
-          "uri" => Format::FileUri.from_path(reference.location.file_path),
+          "uri" => Format::FileUri.from_path(location.file.path),
           "range" => {
-            "start" => { "line" => reference.location.start_line, "character" => reference.location.start_column },
-            "end" => { "line" => reference.location.end_line, "character" => reference.location.end_column }
+            "start" => { "line" => location.start_line, "character" => location.start_column },
+            "end" => { "line" => location.end_line, "character" => location.end_column }
           }
         }
       end

data/lib/holistic/language_server/requests/text_document/go_to_definition.rb

@@ -12,7 +12,8 @@ module Holistic::LanguageServer
         if unsaved_document.has_unsaved_changes?
           ::Holistic::Ruby::Parser::LiveEditing::ProcessFileChanged.call(
             application: request.application,
-            file: unsaved_document.to_file
+            file_path: unsaved_document.path,
+            content: unsaved_document.content
           )
         end
       end
@@ -46,7 +47,7 @@ module Holistic::LanguageServer
           "start" => { "line" => origin_location.start_line, "character" => origin_location.start_column },
           "end" => { "line" => origin_location.end_line, "character" => origin_location.end_column }
         },
-        "targetUri" => Format::FileUri.from_path(target_declaration_location.file_path),
+        "targetUri" => Format::FileUri.from_path(target_declaration_location.file.path),
         "targetRange" => {
           "start" => { "line" => target_declaration_location.start_line, "character" => target_declaration_location.start_column },
           "end" => { "line" => target_declaration_location.end_line, "character" => target_declaration_location.end_column }