holistic-ruby 0.1.4 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abe4144d1f581c6151784152792604f799c0140d62c28f445f377f6039c40457
-  data.tar.gz: 6593b92046a8087f75c171280ae66401ff0bb1eb0f6dba9fa496df127bb39ee8
+  metadata.gz: 43d41e307a4ae8b8b904fda778342ef5d175db25580697f597f606f3aa2a0173
+  data.tar.gz: 5286406cf4e0f5a5cb21745b3f7d49268eb934e4002e76d1ba43f9dfdda034fd
 SHA512:
-  metadata.gz: eb1f43eaa7f78c334da3f8d8f2fc782bfa662b94f8a5a6b5a8a24ab271cae26d62703bd722860dbecf637d9aae5d4595d1424257406d9d349f0d90a95ab702d4
-  data.tar.gz: f42ed13efc65779f8ef175c7127d03cf68bebd5df990a1744d714100efe639cad104b55592507d4737ecfa4d48e75d6b69da194a033f056740a16fde8bf3d65d
+  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/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/ruby/stdlib.rb

@@ -10,7 +10,7 @@ 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
@@ -19,11 +19,11 @@ module Holistic::Extensions::Ruby
     RegisterClassConstructor = ->(application, params) do
       class_scope, location = params[:class_scope], params[:location]
 
-      has_overridden_new_method = class_scope.children.find { _1.class_method? && _1.name == "new" }
+      has_overridden_new_method = class_scope.children.find { _1.instance_method? && _1.name == "initialize" }
 
       unless has_overridden_new_method
-        ::Holistic::Ruby::Scope::Register.call(
-          repository: application.scopes,
+        ::Holistic::Ruby::Scope::Store.call(
+          database: application.database,
           parent: class_scope,
           kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
           name: "new",
@@ -38,8 +38,8 @@ module Holistic::Extensions::Ruby
       lambda_scope, location = params[:lambda_scope], params[:location]
 
       LAMBDA_METHODS.each do |method_name|
-        ::Holistic::Ruby::Scope::Register.call(
-          repository: application.scopes,
+        ::Holistic::Ruby::Scope::Store.call(
+          database: application.database,
           parent: lambda_scope,
           kind: ::Holistic::Ruby::Scope::Kind::CLASS_METHOD,
           name: method_name,

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,22 @@ 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)
-      
+
       return request.respond_with(nil) if code.blank?
 
-      scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.root_scope
+      scope = request.application.scopes.find_inner_most_scope_by_cursor(cursor) || request.application.scopes.root
 
       suggestions = ::Holistic::Ruby::Autocompletion::Suggest.call(code:, scope:)
 

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

@@ -13,19 +13,15 @@ module Holistic::LanguageServer
         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 }

data/lib/holistic/ruby/autocompletion/suggest.rb

@@ -6,6 +6,12 @@ module Holistic::Ruby::Autocompletion
 
     Suggestion = ::Data.define(:code, :kind)
 
+    StartsWithLowerCaseLetter = ->(code) do
+      return false if [".", ":", "@"].include?(code[0])
+
+      code[0] == code[0].downcase
+    end
+
     def call(code:, scope:)
       lookup_scope = scope
 
@@ -13,7 +19,9 @@ module Holistic::Ruby::Autocompletion
         lookup_scope = lookup_scope.parent until lookup_scope.root?
       end
 
-      if code.include?(".")
+      if StartsWithLowerCaseLetter[code]
+        suggest_local_methods_from_current_scope(code:, scope: lookup_scope)
+      elsif code.include?(".")
         suggest_methods_from_scope(code:, scope: lookup_scope)
       else
         suggest_namespaces_from_scope(code:, scope: lookup_scope)
@@ -22,12 +30,32 @@ module Holistic::Ruby::Autocompletion
 
     private
 
-    NonMethods = ->(scope) { !Methods[scope] }
-    Methods    = ->(scope) { scope.instance_method? || scope.class_method? }
+    def suggest_local_methods_from_current_scope(code:, scope:)
+      suggestions = []
+
+      method_to_autocomplete = code
+
+      if scope.instance_method?
+        sibling_methods = scope.parent.children.filter { _1.instance_method? }
+
+        sibling_methods.each do |method_scope|
+          if method_scope.name.start_with?(method_to_autocomplete)
+            suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
+          end
+        end
+      elsif scope.class_method?
+        sibling_methods = scope.parent.children.filter { _1.class_method? }
+
+        sibling_methods.each do |method_scope|
+          if method_scope.name.start_with?(method_to_autocomplete)
+            suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
+          end
+        end
+      end
+
+      suggestions
+    end
 
-    # Payment. <--
-    # Payment::Notifications. <--
-    # current_user.a
     def suggest_methods_from_scope(code:, scope:)
       suggestions = []
 
@@ -41,7 +69,9 @@ module Holistic::Ruby::Autocompletion
         return suggestions if scope.nil?
       end
 
-      scope.children.filter(&:class_method?).each do |method_scope|
+      class_methods = scope.children.filter { _1.class_method? }
+
+      class_methods.each do |method_scope|
         if method_scope.name.start_with?(method_to_autocomplete)
           suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
         end
@@ -63,22 +93,12 @@ module Holistic::Ruby::Autocompletion
         return suggestions if scope.nil?
       end
 
-      # special case when user did not type :: at the end but the current word
-      # is matches an existing namespace. In this case, suggestions will start with ::.
-      # For example:
-      #
-      #                          \/ cursor here
-      # typing: "::MyApp::Payments"
-      # suggestions: ["::Record", "::SendReminder"]
-      resolve_scope(name: namespace_to_autocomplete, from_scope: scope)&.then do |fully_typed_scope|
-        scope = fully_typed_scope
-        namespace_to_autocomplete = ""
-      end
-
       should_search_upwards = namespaces_to_resolve.empty?
 
       search = ->(scope) do
-        scope.children.filter(&NonMethods).each do |child_scope|
+        scope.children.each do |child_scope|
+          next if child_scope.method?
+
           if child_scope.name.start_with?(namespace_to_autocomplete)
             suggestions << Suggestion.new(code: child_scope.name, kind: child_scope.kind)
           end