holistic-ruby 0.1.4 → 0.1.7

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

@@ -6,14 +6,22 @@ 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
 
       if code.start_with?("::")
-        lookup_scope = lookup_scope.parent until lookup_scope.root?
+        lookup_scope = lookup_scope.lexical_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 = []
+
+      sibling_methods =
+        case scope.kind
+        when ::Holistic::Ruby::Scope::Kind::CLASS_METHOD
+          ::Holistic::Ruby::Scope::ListClassMethods.call(scope: scope.lexical_parent)
+        when ::Holistic::Ruby::Scope::Kind::INSTANCE_METHOD
+          ::Holistic::Ruby::Scope::ListInstanceMethods.call(scope: scope.lexical_parent)
+        when ::Holistic::Ruby::Scope::Kind::ROOT
+          # TODO: global functions?
+
+          return []
+        else
+          raise "unexpected scope kind: #{scope.kind}"
+        end
+
+      sibling_methods.each do |method_scope|
+        if method_scope.name.start_with?(code)
+          suggestions << Suggestion.new(code: method_scope.name, kind: method_scope.kind)
+        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 = ::Holistic::Ruby::Scope::ListClassMethods.call(scope:)
+
+      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,28 +93,18 @@ 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.lexical_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
         end
 
-        search.(scope.parent) if scope.parent.present? && should_search_upwards
+        search.(scope.lexical_parent) if scope.lexical_parent.present? && should_search_upwards
       end
 
       search.(scope)
@@ -93,10 +113,10 @@ module Holistic::Ruby::Autocompletion
     end
 
     def resolve_scope(name:, from_scope:)
-      resolved_scope = from_scope.children.find { |scope| scope.name == name }
+      resolved_scope = from_scope.lexical_children.find { |scope| scope.name == name }
 
-      if resolved_scope.nil? && from_scope.parent.present?
-        resolved_scope = resolve_scope(name:, from_scope: from_scope.parent)
+      if resolved_scope.nil? && from_scope.lexical_parent.present?
+        resolved_scope = resolve_scope(name:, from_scope: from_scope.lexical_parent)
       end
 
       resolved_scope

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

@@ -9,9 +9,9 @@ module Holistic::Ruby::Parser
 
     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
@@ -25,9 +25,9 @@ module Holistic::Ruby::Parser
 
       nesting.each do |name|
         @scope =
-          ::Holistic::Ruby::Scope::Register.call(
-            repository: @scope_repository,
-            parent: @scope,
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @scope_repository.database,
+            lexical_parent: @scope,
             kind: ::Holistic::Ruby::Scope::Kind::MODULE,
             name:,
             location:
@@ -52,9 +52,9 @@ module Holistic::Ruby::Parser
 
       nesting.each do |name|
         @scope =
-          ::Holistic::Ruby::Scope::Register.call(
-            repository: @scope_repository,
-            parent: @scope,
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @scope_repository.database,
+            lexical_parent: @scope,
             kind: ::Holistic::Ruby::Scope::Kind::CLASS,
             name:,
             location:
@@ -79,9 +79,9 @@ module Holistic::Ruby::Parser
 
       nesting.each do |name|
         @scope =
-          ::Holistic::Ruby::Scope::Register.call(
-            repository: @scope_repository,
-            parent: @scope,
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @scope_repository.database,
+            lexical_parent: @scope,
             kind:,
             name:,
             location:

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

@@ -4,59 +4,59 @@ module Holistic::Ruby::Parser
   module LiveEditing::ProcessFileChanged
     extend self
 
-    def call(application:, file:)
+    def call(application:, file_path:, content:)
       # TODO: do not build the AST twice
-      return unless HasValidSyntax[file:]
+      return unless HasValidSyntax[content]
 
-      references_to_recalculate = identify_references_to_recalculate(application:, file:)
+      references_to_recalculate = identify_references_to_recalculate(application:, file_path:)
 
-      unregister_scopes_in_file(application:, file:)
-      unregsiter_references_in_file(application:, file:)
+      delete_scopes_in_file(application:, file_path:)
+      delete_references_in_file(application:, file_path:)
 
-      parse_again(application:, file:)
+      parse_again(application:, file_path:, content:)
 
-      recalculate_type_inference_for_references(application:, references: references_to_recalculate)
+      recalculate_type_inference(application:, references: references_to_recalculate)
     end
 
     private
 
-    def identify_references_to_recalculate(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
       # 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:)
+    def recalculate_type_inference(application:, references:)
       references.each do |reference|
-        reference.conclusion = ::Holistic::Ruby::TypeInference::Conclusion.pending
+        reference.relation(:referenced_scope).delete!(reference.referenced_scope)
 
         ::Holistic::Ruby::TypeInference::Solve.call(application:, reference:)
       end

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

@@ -14,28 +14,43 @@ 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
-
-        if superclass_node
-          register_reference(nesting: NestingSyntax.build(superclass_node), location: build_location(superclass_node))
-        end
+        declaration_node, superclass_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)
 
         class_scope = @constant_resolution.register_child_class(nesting:, location:) do
-          visit(body_node)
+          visit(body_statements_node)
+        end
+
+        if superclass_node
+          reference_to_scope_clue = ::Holistic::Ruby::TypeInference::Clue::ScopeReference.new(
+            nesting: NestingSyntax.build(superclass_node),
+            resolution_possibilities: @constant_resolution.current
+          )
+
+          reference_to_superclass_clue = ::Holistic::Ruby::TypeInference::Clue::ReferenceToSuperclass.new(
+            subclass_scope: class_scope
+          )
+
+          ::Holistic::Ruby::Reference::Store.call(
+            database: @application.database,
+            processing_queue: @application.type_inference_processing_queue,
+            scope: @constant_resolution.scope,
+            clues: [reference_to_scope_clue, reference_to_superclass_clue],
+            location: build_location(superclass_node)
+          )
         end
 
         @application.extensions.dispatch(:class_scope_registered, { class_scope:, location: })
@@ -50,14 +65,35 @@ module Holistic::Ruby::Parser
           @constant_resolution.change_method_registration_mode_to_class_methods! if is_extending_self
         end
 
+        if command_name_node.value == "include"
+          superclass_nesting_syntax = NestingSyntax.build(args_node.child_nodes.first)
+
+          reference_to_scope_clue = ::Holistic::Ruby::TypeInference::Clue::ScopeReference.new(
+            nesting: superclass_nesting_syntax,
+            resolution_possibilities: @constant_resolution.current
+          )
+
+          reference_to_superclass_clue = ::Holistic::Ruby::TypeInference::Clue::ReferenceToSuperclass.new(
+            subclass_scope: @constant_resolution.scope
+          )
+
+          ::Holistic::Ruby::Reference::Store.call(
+            database: @application.database,
+            processing_queue: @application.type_inference_processing_queue,
+            scope: @constant_resolution.scope,
+            clues: [reference_to_scope_clue, reference_to_superclass_clue],
+            location: build_location(node)
+          )
+        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:)
+        location = build_scope_location(declaration_node: method_name_node, body_node: node)
 
         kind =
           if instance_node.present? && instance_node.child_nodes.first.value == "self"
@@ -69,7 +105,7 @@ module Holistic::Ruby::Parser
           end
 
         @constant_resolution.register_child_method(nesting:, location:, kind:) do
-          visit(body_node)
+          visit(body_statements_node)
         end
       end
 
@@ -80,8 +116,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)
@@ -114,8 +151,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)
@@ -151,9 +189,9 @@ module Holistic::Ruby::Parser
         location = build_scope_location(declaration_node: assign_node, body_node:)
 
         lambda_scope =
-          ::Holistic::Ruby::Scope::Register.call(
-            repository: @application.scopes,
-            parent: @constant_resolution.scope,
+          ::Holistic::Ruby::Scope::Store.call(
+            database: @application.database,
+            lexical_parent: @constant_resolution.scope,
             kind: ::Holistic::Ruby::Scope::Kind::LAMBDA,
             name: assign_node.child_nodes.first.value,
             location:
@@ -185,8 +223,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:
@@ -209,13 +248,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,34 +1,74 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::Parser
-  HasValidSyntax = ->(file:) do
-    ::SyntaxTree.parse(file.read)
+  HasValidSyntax = ->(content) do
+    ::SyntaxTree.parse(content)
 
     true
   rescue ::SyntaxTree::Parser::ParseError
     false
   end
 
-  ParseFile = ->(application:, file:) do
-    program = ::SyntaxTree.parse(file.read)
+  ParseFile = ->(application:, file_path:, content:) do
+    program = ::SyntaxTree.parse(content)
 
-    constant_resolution = ConstantResolution.new(
-      scope_repository: application.scopes,
-      root_scope: application.root_scope
-    )
+    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:)
 
     visitor.visit(program)
   rescue ::SyntaxTree::Parser::ParseError
-    ::Holistic.logger.info("syntax error on file #{file.path}")
+    ::Holistic.logger.info("syntax error on file #{file_path}")
+  end
+
+  class PerformanceMetrics
+    def initialize
+      @amount_of_files  = 0
+      @total_read_time  = 0
+      @total_parse_time = 0
+    end
+
+    def start_file_read!
+      @amount_of_files += 1
+      @file_read_before = ::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def end_file_read!
+      @total_read_time += ::Process.clock_gettime(Process::CLOCK_MONOTONIC) - @file_read_before
+    end
+
+    def start_parse!
+      @parse_before = ::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def end_parse!
+      @total_parse_time += ::Process.clock_gettime(Process::CLOCK_MONOTONIC) - @parse_before
+    end
+
+    def inspect
+      {
+        amount_of_files:  @amount_of_files,
+        total_read_time:  @total_read_time,
+        total_parse_time: @total_parse_time
+      }.inspect
+    end
   end
 
   ParseDirectory = ->(application:, directory_path:) do
+    performance_metrics = PerformanceMetrics.new
+
     ::Dir.glob("#{directory_path}/**/*.rb").map do |file_path|
-      file = ::Holistic::Document::File.new(path: file_path)
+      performance_metrics.start_file_read!
+      content = ::File.read(file_path)
+      performance_metrics.end_file_read!
 
-      ParseFile[application:, file:]
+      performance_metrics.start_parse!
+      ParseFile.call(application:, file_path:, content:)
+      performance_metrics.end_parse!
     end
+
+    performance_metrics
   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)
+
+      reference.relation(:reference_defined_in_file).delete!(reference.location.file)
+      reference.relation(:located_in_scope).delete!(reference.located_in_scope)
+
+      if reference.referenced_scope
+        reference.relation(:referenced_scope).delete!(reference.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,20 @@
 # 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)
+
+    def find_clue(clue_kind)
+      clues.find { |clue| clue.is_a?(clue_kind) }
+    end
+
+    def inspect
+      "<#{self.class.name} clues=[#{clues}] referenced_scope=#{referenced_scope&.fully_qualified_name}>"
+    end
   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.to_a
       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