holistic-ruby 0.1.1 → 0.1.6

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,12 +19,66 @@ module Holistic::Ruby::Autocompletion
         lookup_scope = lookup_scope.parent until lookup_scope.root?
       end
 
-      suggest_namespaces_from_scope(code:, scope: lookup_scope)
+      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)
+      end
     end
 
     private
 
-    NonMethods = ->(scope) { !scope.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
+
+    def suggest_methods_from_scope(code:, scope:)
+      suggestions = []
+
+      partial_namespaces = code.split(/(::|\.)/).compact_blank
+      method_to_autocomplete = partial_namespaces.pop.then { _1 == "." ? "" : _1 }
+      namespaces_to_resolve = partial_namespaces.reject { _1 == "::" || _1 == "." }
+
+      namespaces_to_resolve.each do |namespace_name|
+        scope = resolve_scope(name: namespace_name, from_scope: scope)
+
+        return suggestions if scope.nil?
+      end
+
+      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
+      end
+
+      suggestions
+    end
 
     def suggest_namespaces_from_scope(code:, scope:)
       suggestions = []
@@ -33,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

data/lib/holistic/ruby/parser/constant_resolution.rb

@@ -2,12 +2,18 @@
 
 module Holistic::Ruby::Parser
   class ConstantResolution
-    attr_reader :scope_repository, :scope
+    module MethodRegistrationMode
+      INSTANCE_METHODS = :instance_methods
+      CLASS_METHODS    = :class_methods
+    end
+
+    attr_reader :scope_repository, :scope, :method_registration_mode
 
-    def initialize(scope_repository:, root_scope:)
+    def initialize(scope_repository:)
       @scope_repository = scope_repository
-      @scope = root_scope
+      @scope = scope_repository.root
       @constant_resolution_possibilities = ["::"]
+      @method_registration_mode = MethodRegistrationMode::INSTANCE_METHODS
     end
 
     def current
@@ -19,8 +25,8 @@ module Holistic::Ruby::Parser
 
       nesting.each do |name|
         @scope =
-          ::Holistic::Ruby::Scope::Register.call(
-            repository: @scope_repository,
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @scope_repository.database,
             parent: @scope,
             kind: ::Holistic::Ruby::Scope::Kind::MODULE,
             name:,
@@ -28,12 +34,17 @@ module Holistic::Ruby::Parser
           )
       end
 
+      registered_module_scope = @scope
+
       @constant_resolution_possibilities.unshift(@scope.fully_qualified_name)
 
       block.call
 
-      @scope = starting_scope
+      change_method_registration_mode_to_instance_methods!
       @constant_resolution_possibilities.shift
+      @scope = starting_scope
+
+      registered_module_scope
     end
 
     def register_child_class(nesting:, location:, &block)
@@ -41,8 +52,8 @@ module Holistic::Ruby::Parser
 
       nesting.each do |name|
         @scope =
-          ::Holistic::Ruby::Scope::Register.call(
-            repository: @scope_repository,
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @scope_repository.database,
             parent: @scope,
             kind: ::Holistic::Ruby::Scope::Kind::CLASS,
             name:,
@@ -50,12 +61,52 @@ module Holistic::Ruby::Parser
           )
       end
 
+      registered_class_scope = @scope
+
       @constant_resolution_possibilities.unshift(@scope.fully_qualified_name)
 
       block.call
 
-      @scope = starting_scope
+      change_method_registration_mode_to_instance_methods!
       @constant_resolution_possibilities.shift
+      @scope = starting_scope
+
+      registered_class_scope
+    end
+
+    def register_child_method(nesting:, location:, kind:, &block)
+      starting_scope = @scope
+
+      nesting.each do |name|
+        @scope =
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @scope_repository.database,
+            parent: @scope,
+            kind:,
+            name:,
+            location:
+          )
+      end
+
+      registered_method_scope = @scope
+
+      block.call
+
+      @scope = starting_scope
+
+      registered_method_scope
+    end
+
+    def method_registration_class_methods?
+      method_registration_mode == MethodRegistrationMode::CLASS_METHODS
+    end
+
+    def change_method_registration_mode_to_class_methods!
+      @method_registration_mode = MethodRegistrationMode::CLASS_METHODS
+    end
+
+    def change_method_registration_mode_to_instance_methods!
+      @method_registration_mode = MethodRegistrationMode::INSTANCE_METHODS
     end
   end
 end

data/lib/holistic/ruby/parser/live_editing/process_file_changed.rb

@@ -4,56 +4,59 @@ module Holistic::Ruby::Parser
   module LiveEditing::ProcessFileChanged
     extend self
 
-    def call(application:, file:)
-      references_to_recalculate = identify_references_to_recalculate_type_inference(application:, file:)
+    def call(application:, file_path:, content:)
+      # TODO: do not build the AST twice
+      return unless HasValidSyntax[content]
 
-      unregister_scopes_in_file(application:, file:)
-      unregsiter_references_in_file(application:, file:)
+      references_to_recalculate = identify_references_to_recalculate(application:, file_path:)
 
-      parse_again(application:, file:)
+      delete_scopes_in_file(application:, file_path:)
+      delete_references_in_file(application:, file_path:)
+
+      parse_again(application:, file_path:, content:)
 
       recalculate_type_inference_for_references(application:, references: references_to_recalculate)
     end
 
     private
 
-    def identify_references_to_recalculate_type_inference(application:, file:)
+    def identify_references_to_recalculate(application:, file_path:)
       # we need to reject references declared in the same because they're already going to be
-      # unregistered and reparsed. If we don't do that, we'll end up with duplicated reference records. 
+      # reparsed. If we don't do that, we'll end up with duplicated reference records. 
 
       application.references
-        .list_references_to_scopes_in_file(scopes: application.scopes, file_path: file.path)
-        .reject { _1.location.file_path == file.path }
+        .list_references_to_scopes_in_file(scopes: application.scopes, file_path: file_path)
+        .reject { _1.location.file.path == file_path }
     end
 
-    def unregister_scopes_in_file(application:, file:)
-      application.scopes.list_scopes_in_file(file.path).each do |scope|
-        ::Holistic::Ruby::Scope::Unregister.call(
-          repository: application.scopes,
+    def delete_scopes_in_file(application:, file_path:)
+      application.scopes.list_scopes_in_file(file_path).each do |scope|
+        ::Holistic::Ruby::Scope::Delete.call(
+          database: application.database,
           fully_qualified_name: scope.fully_qualified_name,
-          file_path: file.path
+          file_path:
         )
       end
     end
 
-    def unregsiter_references_in_file(application:, file:)
-      application.references.list_references_in_file(file.path).each do |reference|
-        ::Holistic::Ruby::Reference::Unregister.call(
-          repository: application.references,
+    def delete_references_in_file(application:, file_path:)
+      application.references.list_references_in_file(file_path).each do |reference|
+        ::Holistic::Ruby::Reference::Delete.call(
+          database: application.database,
           reference: reference
         )
       end
     end
 
-    def parse_again(application:, file:)
-      ParseFile.call(application:, file:)
+    def parse_again(application:, file_path:, content:)
+      ParseFile.call(application:, file_path:, content:)
 
       ::Holistic::Ruby::TypeInference::SolvePendingReferences.call(application:)
     end
 
     def recalculate_type_inference_for_references(application:, references:)
       references.each do |reference|
-        reference.conclusion = ::Holistic::Ruby::TypeInference::Conclusion.pending
+        application.database.disconnect(source: reference.referenced_scope, target: reference, name: :referenced_by, inverse_of: :referenced_scope)
 
         ::Holistic::Ruby::TypeInference::Solve.call(application:, reference:)
       end

data/lib/holistic/ruby/parser/nesting_syntax.rb

@@ -14,6 +14,7 @@ module Holistic::Ruby::Parser
         when ::SyntaxTree::Const        then nesting_syntax << node.value
         when ::SyntaxTree::VCall        then append.(node.child_nodes.first)
         when ::SyntaxTree::Ident        then nesting_syntax << node.value
+        when ::SyntaxTree::Kw           then nesting_syntax << node.value
         when ::SyntaxTree::IVar         then nesting_syntax << node.value
         when ::SyntaxTree::Period       then nesting_syntax << "."
         when ::SyntaxTree::Paren        then append.(node.child_nodes[1])       # node.child_nodes[0] is ::SyntaxTree::LParen

data/lib/holistic/ruby/parser/program_visitor.rb

@@ -14,52 +14,63 @@ module Holistic::Ruby::Parser
 
     visit_methods do
       def visit_module(node)
-        declaration_node, body_node = node.child_nodes
+        declaration_node, body_statements_node = node.child_nodes
 
         nesting = NestingSyntax.build(declaration_node)
-        location = build_scope_location(declaration_node:, body_node:)
+        location = build_scope_location(declaration_node:, body_node: node)
 
         @constant_resolution.register_child_module(nesting:, location:) do
-          visit(body_node)
+          visit(body_statements_node)
         end
       end
 
       def visit_class(node)
-        declaration_node, superclass_node, body_node = node.child_nodes
+        declaration_node, superclass_node, body_statements_node = node.child_nodes
 
         if superclass_node
           register_reference(nesting: NestingSyntax.build(superclass_node), location: build_location(superclass_node))
         end
 
         nesting = NestingSyntax.build(declaration_node)
-        location = build_scope_location(declaration_node:, body_node:)
+        location = build_scope_location(declaration_node:, body_node: node)
 
-        @constant_resolution.register_child_class(nesting:, location:) do
-          visit(body_node)
+        class_scope = @constant_resolution.register_child_class(nesting:, location:) do
+          visit(body_statements_node)
+        end
+
+        @application.extensions.dispatch(:class_scope_registered, { class_scope:, location: })
+      end
+
+      def visit_command(node)
+        command_name_node, args_node = node.child_nodes
+
+        if command_name_node.value == "extend"
+          is_extending_self = args_node.child_nodes.size == 1 && NestingSyntax.build(args_node.child_nodes.first).to_s == "self"
+
+          @constant_resolution.change_method_registration_mode_to_class_methods! if is_extending_self
         end
+
+        visit(args_node)
       end
 
       def visit_def(node)
-        instance_node, period_node, method_name_node, _params, body_node = node.child_nodes
+        instance_node, period_node, method_name_node, _params, body_statements_node = node.child_nodes
+
+        nesting = NestingSyntax.new(method_name_node.value)
+        location = build_scope_location(declaration_node: method_name_node, body_node: node)
 
-        method_name =
-          if instance_node.present? && period_node.present?
-            instance_node.child_nodes.first.value + period_node.value + method_name_node.value
+        kind =
+          if instance_node.present? && instance_node.child_nodes.first.value == "self"
+            ::Holistic::Ruby::Scope::Kind::CLASS_METHOD
+          elsif @constant_resolution.method_registration_class_methods?
+            ::Holistic::Ruby::Scope::Kind::CLASS_METHOD
           else
-            method_name_node.value
+            ::Holistic::Ruby::Scope::Kind::INSTANCE_METHOD
           end
 
-        location = build_scope_location(declaration_node: method_name_node, body_node:)
-
-        ::Holistic::Ruby::Scope::Register.call(
-          repository: @application.scopes,
-          parent: @constant_resolution.scope,
-          kind: ::Holistic::Ruby::Scope::Kind::METHOD,
-          name: method_name,
-          location:
-        )
-
-        visit(body_node)
+        @constant_resolution.register_child_method(nesting:, location:, kind:) do
+          visit(body_statements_node)
+        end
       end
 
       def visit_vcall(node)
@@ -69,8 +80,9 @@ module Holistic::Ruby::Parser
           resolution_possibilities: @constant_resolution.current
         )
 
-        ::Holistic::Ruby::Reference::Register.call(
-          repository: @application.references,
+        ::Holistic::Ruby::Reference::Store.call(
+          database: @application.database,
+          processing_queue: @application.type_inference_processing_queue,
           scope: @constant_resolution.scope,
           clues: [method_call_clue],
           location: build_location(node)
@@ -103,8 +115,9 @@ module Holistic::Ruby::Parser
           resolution_possibilities: @constant_resolution.current
         )
 
-        ::Holistic::Ruby::Reference::Register.call(
-          repository: @application.references,
+        ::Holistic::Ruby::Reference::Store.call(
+          database: @application.database,
+          processing_queue: @application.type_inference_processing_queue,
           scope: @constant_resolution.scope,
           clues: [method_call_clue],
           location: build_location(method_name_node || instance_node)
@@ -128,22 +141,27 @@ module Holistic::Ruby::Parser
           nesting = NestingSyntax.build(assign_node)
           location = build_scope_location(declaration_node: assign_node, body_node: block_node)
 
-          @constant_resolution.register_child_class(nesting:, location:) do
+          class_scope = @constant_resolution.register_child_class(nesting:, location:) do
             visit(block_node)
           end
 
+          @application.extensions.dispatch(:class_scope_registered, { class_scope:, location: })
+
           return
         end
 
         location = build_scope_location(declaration_node: assign_node, body_node:)
 
-        ::Holistic::Ruby::Scope::Register.call(
-          repository: @application.scopes,
-          parent: @constant_resolution.scope,
-          kind: ::Holistic::Ruby::Scope::Kind::LAMBDA,
-          name: assign_node.child_nodes.first.value,
-          location:
-        )
+        lambda_scope =
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @application.database,
+            parent: @constant_resolution.scope,
+            kind: ::Holistic::Ruby::Scope::Kind::LAMBDA,
+            name: assign_node.child_nodes.first.value,
+            location:
+          )
+
+        @application.extensions.dispatch(:lambda_scope_registered, { lambda_scope:, location: })
 
         visit(body_node)
       end
@@ -169,8 +187,9 @@ module Holistic::Ruby::Parser
         resolution_possibilities: @constant_resolution.current
       )
 
-      ::Holistic::Ruby::Reference::Register.call(
-        repository: @application.references,
+      ::Holistic::Ruby::Reference::Store.call(
+        database: @application.database,
+        processing_queue: @application.type_inference_processing_queue,
         scope: @constant_resolution.scope,
         clues: [clue],
         location:
@@ -193,13 +212,7 @@ module Holistic::Ruby::Parser
       start_column = node.location.start_column
       end_column   = node.location.end_column
 
-      # syntax_tree seems to have a bug with the bodystmt node.
-      # It sets the end_column lower than the start_column.
-      if start_line == end_line && start_column > end_column
-        start_column, end_column = end_column, start_column
-      end
-
-      ::Holistic::Document::Location.new(file_path: file.path, start_line:, start_column:, end_line:, end_column:)
+      ::Holistic::Document::Location.new(file:, start_line:, start_column:, end_line:, end_column:)
     end
   end
 end

data/lib/holistic/ruby/parser.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::Parser
-  ParseFile = ->(application:, file:) do
-    program = ::SyntaxTree.parse(file.read)
+  HasValidSyntax = ->(content) do
+    ::SyntaxTree.parse(content)
 
-    constant_resolution = ConstantResolution.new(
-      scope_repository: application.scopes,
-      root_scope: application.root_scope
-    )
+    true
+  rescue ::SyntaxTree::Parser::ParseError
+    false
+  end
+
+  ParseFile = ->(application:, file_path:, content:) do
+    program = ::SyntaxTree.parse(content)
+
+    constant_resolution = ConstantResolution.new(scope_repository: application.scopes)
+
+    file = ::Holistic::Document::File::Store.call(database: application.database, file_path:)
 
     visitor = ProgramVisitor.new(application:, constant_resolution:, file:)
 
@@ -18,9 +25,7 @@ module Holistic::Ruby::Parser
 
   ParseDirectory = ->(application:, directory_path:) do
     ::Dir.glob("#{directory_path}/**/*.rb").map do |file_path|
-      file = ::Holistic::Document::File.new(path: file_path)
-
-      ParseFile[application:, file:]
+      ParseFile.call(application:, file_path:, content: ::File.read(file_path))
     end
   end
 end

data/lib/holistic/ruby/reference/delete.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Reference
+  module Delete
+    extend self
+
+    def call(database:, reference:)
+      database.delete(reference.identifier)
+
+      database.disconnect(source: reference.location.file, target: reference, name: :defines_references, inverse_of: :reference_defined_in_file)
+      database.disconnect(source: reference.located_in_scope, target: reference, name: :contains_many_references, inverse_of: :located_in_scope)
+
+      if reference.referenced_scope
+        database.disconnect(source: reference.referenced_scope, target: reference, name: :referenced_by, inverse_of: :referenced_scope)
+      end
+    end
+  end
+end

data/lib/holistic/ruby/reference/find_referenced_scope.rb

@@ -8,9 +8,9 @@ module Holistic::Ruby::Reference
       reference = application.references.find_by_cursor(cursor)
 
       return :not_found if reference.nil?
-      return :could_not_find_referenced_scope if reference.conclusion.dependency_identifier.nil?
+      return :could_not_find_referenced_scope if reference.referenced_scope.nil?
 
-      referenced_scope = application.scopes.find_by_fully_qualified_name(reference.conclusion.dependency_identifier)
+      referenced_scope = reference.referenced_scope
 
       [:referenced_scope_found, {reference:, referenced_scope:}]
     end

data/lib/holistic/ruby/reference/record.rb

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::Reference
-  Record = ::Struct.new(
-    :scope,
-    :clues,
-    :conclusion,
-    :location,
-    keyword_init: true
-  ) do
-    def identifier = location.identifier
+  class Record < ::Holistic::Database::Node
+    def identifier = attr(:identifier)
+    def clues      = attr(:clues)
+    def location   = attr(:location)
+
+    def referenced_scope = has_one(:referenced_scope)
+    def located_in_scope = has_one(:located_in_scope)
   end
 end

data/lib/holistic/ruby/reference/repository.rb

@@ -2,68 +2,46 @@
 
 module Holistic::Ruby::Reference
   class Repository
-    attr_reader :table
+    attr_reader :database
 
-    INDICES = [
-      :file_path,
-      :type_inference_status,
-      :referenced_scope_fully_qualified_name
-    ].freeze
-
-    def initialize
-      @table = ::Holistic::Database::Table.new(primary_attribute: :identifier, indices: INDICES)
-    end
-
-    def register_reference(reference)
-      table.update({
-        reference:,
-        identifier: reference.identifier,
-        file_path: reference.location.file_path,
-        type_inference_status: reference.conclusion.status,
-        referenced_scope_fully_qualified_name: reference.conclusion.dependency_identifier
-      })
+    def initialize(database:)
+      @database = database
     end
 
     def find_by_cursor(cursor)
-      table.filter(:file_path, cursor.file_path).map { _1[:reference] }.each do |reference|
-        return reference if reference.location.contains?(cursor)
+      @database.find(cursor.file_path)&.then do |file|
+        file.defines_references.find do |reference|
+          reference.location.contains?(cursor)
+        end
       end
-
-      nil
-    end
-
-    def list_references_to(fully_qualified_scope_name)
-      table.filter(:referenced_scope_fully_qualified_name, fully_qualified_scope_name).map { _1[:reference] }
     end
 
     def list_references_in_file(file_path)
-      table.filter(:file_path, file_path).map { _1[:reference] }
+      @database.find(file_path)&.defines_references || []
     end
 
     def list_references_to_scopes_in_file(scopes:, file_path:)
-      scopes.list_scopes_in_file(file_path).flat_map do |scope|
-        table.filter(:referenced_scope_fully_qualified_name, scope.fully_qualified_name).map { _1[:reference] }
+      references = @database.find(file_path)&.defines_scopes&.flat_map do |scope|
+        scope.referenced_by
       end
-    end
-
-    def list_references_pending_type_inference_conclusion
-      table.filter(:type_inference_status, ::Holistic::Ruby::TypeInference::STATUS_PENDING).map { _1[:reference] }
-    end
 
-    def delete(identifier)
-      table.delete(identifier)
+      references || []
     end
 
     concerning :TestHelpers do
+      def all
+        @database.all.filter { _1.is_a?(Record) }
+      end
+
       def find_reference_to(scope_name)
-        table.all.map { _1[:reference] }.find do |reference|
-          reference.conclusion.dependency_identifier == scope_name || reference.clues.find { _1.to_s == scope_name }
+        all.find do |node|
+          node.referenced_scope&.fully_qualified_name == scope_name || node.clues&.find { _1.to_s == scope_name }
         end
       end
 
       def find_by_code_content(code_content)
-        table.all.map { _1[:reference] }.find do |reference|
-          reference.clues.find { _1.to_s == code_content }
+        all.find do |node|
+          node.clues&.find { _1.to_s == code_content }
         end
       end
     end