holistic-ruby 0.1.4 → 0.1.6

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,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:,
@@ -52,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:,
@@ -79,8 +79,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:,
             name:,

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)
     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:)
       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/program_visitor.rb

@@ -14,28 +14,28 @@ 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)
 
         class_scope = @constant_resolution.register_child_class(nesting:, location:) do
-          visit(body_node)
+          visit(body_statements_node)
         end
 
         @application.extensions.dispatch(:class_scope_registered, { class_scope:, location: })
@@ -54,10 +54,10 @@ module Holistic::Ruby::Parser
       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 +69,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 +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)
@@ -114,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)
@@ -151,8 +153,8 @@ module Holistic::Ruby::Parser
         location = build_scope_location(declaration_node: assign_node, body_node:)
 
         lambda_scope =
-          ::Holistic::Ruby::Scope::Register.call(
-            repository: @application.scopes,
+          ::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,
@@ -185,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:
@@ -209,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,21 +1,20 @@
 # 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:)
 
@@ -26,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

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Reference
+  module Store
+    extend self
+
+    def call(database:, processing_queue:, scope:, clues:, location:)
+      record = Record.new(location.identifier, { identifier: location.identifier, clues:, location: })
+
+      reference = database.store(location.identifier, record)
+
+      database.connect(source: scope, target: reference, name: :contains_many_references, inverse_of: :located_in_scope)
+      database.connect(source: location.file, target: reference, name: :defines_references, inverse_of: :reference_defined_in_file)
+
+      processing_queue.push(reference)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope
+  module Delete
+    extend self
+
+    def call(database:, fully_qualified_name:, file_path:)
+      scope = database.find(fully_qualified_name)
+
+      return :scope_not_found if scope.nil?
+
+      location_to_remove = scope.locations.find { |scope_location| scope_location.declaration.file.path == file_path }
+
+      return :scope_not_defined_in_speciefied_file if location_to_remove.nil?
+
+      scope.locations.delete(location_to_remove)
+
+      database.disconnect(source: location_to_remove.declaration.file, target: scope, name: :defines_scopes, inverse_of: :scope_defined_in_file)
+
+      if scope.locations.empty?
+        database.disconnect(source: scope.parent, target: scope, name: :children, inverse_of: :parent)
+
+        database.delete(fully_qualified_name)
+      end
+
+      :definition_unregistered
+    end
+  end
+end

data/lib/holistic/ruby/scope/lexical.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope::Lexical
+  extend self
+
+  def descendant?(child:, parent:)
+    child_parent = child.parent
+
+    child_parent.present? && (child_parent == parent || descendant?(child: child_parent, parent:))
+  end
+end

data/lib/holistic/ruby/scope/list_references.rb

@@ -5,7 +5,7 @@ module Holistic::Ruby::Scope
     extend self
 
     QueryReferencesRecursively = ->(application, scope) do
-      references_to_scope = application.references.list_references_to(scope.fully_qualified_name)
+      references_to_scope = scope.referenced_by
 
       references_to_child_scopes = scope.children.flat_map { QueryReferencesRecursively.call(application, _1) }
 
@@ -14,7 +14,7 @@ module Holistic::Ruby::Scope
 
     Relevance = ->(reference) do
       # TODO: should the location answer the kind of file it is? application code, config, spec, etc. Not sure.
-      looks_like_a_spec = reference.location.file_path.include?("_spec.rb") || reference.location.file_path.include?("_test.rb")
+      looks_like_a_spec = reference.location.file.path.include?("_spec.rb") || reference.location.file.path.include?("_test.rb")
 
       looks_like_a_spec ? 1 : 0
     end

data/lib/holistic/ruby/scope/location.rb

@@ -3,13 +3,11 @@
 module Holistic::Ruby::Scope
   class Location
     class Collection
-      attr_reader :scope, :items
+      attr_reader :scope_name, :items
 
-      def initialize(scope, location)
-        raise ::ArgumentError if location.present? && !location.is_a?(Location)
-
-        @scope = scope
-        @items = location.nil? ? [] : [location]
+      def initialize(scope_name)
+        @scope_name = scope_name
+        @items = []
       end
 
       def main
@@ -18,17 +16,19 @@ module Holistic::Ruby::Scope
 
       delegate :<<,      to: :items
       delegate :each,    to: :items
+      delegate :find,    to: :items
       delegate :map,     to: :items
-      delegate :reject!, to: :items
+      delegate :delete,  to: :items
       delegate :any?,    to: :items
+      delegate :empty?,  to: :items
 
       private
 
       def location_matching_scope_name
-        scope_name_in_snake_case = scope.name.underscore
+        scope_name_in_snake_case = scope_name.underscore
 
         items.find do |location|
-          ::File.basename(location.declaration.file_path) == "#{scope_name_in_snake_case}.rb"
+          ::File.basename(location.declaration.file.path) == "#{scope_name_in_snake_case}.rb"
         end
       end
     end

data/lib/holistic/ruby/scope/outline.rb

@@ -18,18 +18,18 @@ module Holistic::Ruby::Scope
 
     QueryDependenciesRecursively = ->(application, outlined_scope, scope) do
       is_local_dependency = ->(reference) do
-        scope = application.scopes.find_by_fully_qualified_name(reference.conclusion.dependency_identifier)
+        scope = reference.referenced_scope
 
-        scope.eql?(outlined_scope) || scope.descendant?(outlined_scope)
+        scope == outlined_scope || Lexical.descendant?(child: scope, parent: outlined_scope)
       end
 
       dependencies = []
 
       scope.locations.each do |scope_location|
         application.references
-          .list_references_in_file(scope_location.declaration.file_path)
-          .filter { |reference| reference.scope == scope }
-          .filter { |reference| reference.conclusion.dependency_identifier.present? }
+          .list_references_in_file(scope_location.declaration.file.path)
+          .filter { |reference| reference.located_in_scope == scope }
+          .filter { |reference| reference.referenced_scope.present? }
           .reject(&is_local_dependency)
           .tap { dependencies.concat(_1) }
       end
@@ -40,11 +40,11 @@ module Holistic::Ruby::Scope
     def call(application:, scope:)
       declarations = QueryChildScopesRecursively.call(application, scope).sort_by { _1.fully_qualified_name }
 
-      dependencies = QueryDependenciesRecursively.call(application, scope, scope).uniq { _1.conclusion.dependency_identifier }
+      dependencies = QueryDependenciesRecursively.call(application, scope, scope).uniq
 
-      references = application.references.list_references_to(scope.fully_qualified_name)
+      references = scope.referenced_by
 
-      dependants = references.map { |reference| reference.scope }.uniq
+      dependants = references.map { |reference| reference.located_in_scope }.uniq
 
       Result.new(declarations:, dependencies:, references:, dependants:)
     end

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

@@ -1,56 +1,20 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::Scope
-  class Record
-    attr_reader :kind, :name, :parent, :children, :locations
-
-    def initialize(kind:, name:, parent:, location: nil)
-      @kind = kind
-      @name = name
-      @parent = parent
-      @locations = Location::Collection.new(self, location)
-      @children = []
-    end
-
-    def fully_qualified_name
-      return "" if root?
-
-      separator =
-        case kind
-        when Kind::INSTANCE_METHOD then "#"
-        when Kind::CLASS_METHOD    then "."
-        else "::"
-        end
-
-      "#{parent.fully_qualified_name}#{separator}#{name}"
-    end
-
-    def root?
-      parent.nil?
-    end
-
-    def lambda?
-      kind == Kind::LAMBDA
-    end
-
-    def class?
-      kind == Kind::CLASS
-    end
-
-    def module?
-      kind == Kind::MODULE
-    end
-
-    def instance_method?
-      kind == Kind::INSTANCE_METHOD
-    end
-
-    def class_method?
-      kind == Kind::CLASS_METHOD
-    end
-
-    def descendant?(other)
-      parent.present? && (parent == other || parent.descendant?(other))
-    end
+  class Record < ::Holistic::Database::Node
+    def fully_qualified_name = attr(:fully_qualified_name)
+    def locations            = attr(:locations)
+    def name                 = attr(:name)
+    def kind                 = attr(:kind)
+
+    def parent        = has_one(:parent)
+    def children      = has_many(:children)
+    def referenced_by = has_many(:referenced_by)
+
+    def root?            = kind == Kind::ROOT
+    def class?           = kind == Kind::CLASS
+    def class_method?    = kind == Kind::CLASS_METHOD
+    def instance_method? = kind == Kind::INSTANCE_METHOD
+    def method?          = class_method? || instance_method?
   end
 end