holistic-ruby 0.1.1 → 0.1.6

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/kind.rb

@@ -2,10 +2,11 @@
 
 module Holistic::Ruby::Scope
   module Kind
-    ROOT   = :root
-    MODULE = :module
-    CLASS  = :class
-    METHOD = :method
-    LAMBDA = :lambda
+    ROOT            = :root
+    MODULE          = :module
+    CLASS           = :class
+    INSTANCE_METHOD = :instance_method
+    CLASS_METHOD    = :class_method
+    LAMBDA          = :lambda
   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,52 +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 =
-        if kind == Kind::METHOD
-          "#"
-        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 method?
-      kind == Kind::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

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

@@ -2,48 +2,47 @@
 
 module Holistic::Ruby::Scope
   class Repository
-    attr_reader :table
-
-    def initialize
-      @table = ::Holistic::Database::Table.new(primary_attribute: :fully_qualified_name, indices: [:file_paths])
-    end
-
-    def register_scope(scope)
-      table.update({
-        fully_qualified_name: scope.fully_qualified_name,
-        file_paths: scope.locations.map { |scope_location| scope_location.declaration.file_path },
-        scope:
-      })
+    attr_reader :database, :root
+
+    def initialize(database:)
+      @root = database.store(
+        "root_scope", 
+        Record.new("root_scope", {
+          fully_qualified_name: "::",
+          name: "::",
+          kind: Kind::ROOT 
+        })
+      )
+
+      @database = database
     end
 
-    def find_by_fully_qualified_name(fully_qualified_name)
-      table.find(fully_qualified_name).try(:dig, :scope)
+    def find(fully_qualified_name)
+      database.find(fully_qualified_name)
     end
 
     def find_by_cursor(cursor)
-      table.filter(:file_paths, cursor.file_path).map { _1[:scope] }.each do |scope|
-        return scope if scope.locations.any? { _1.declaration.contains?(cursor) }
+      database.find(cursor.file_path)&.then do |file|
+        file.defines_scopes.find do |scope|
+          scope.locations.any? { _1.declaration.contains?(cursor) }
+        end
       end
-
-      nil
     end
 
     def find_inner_most_scope_by_cursor(cursor)
-      scopes = table.filter(:file_paths, cursor.file_path).map { _1[:scope] }
+      file = database.find(cursor.file_path)
 
-      matching_scopes = scopes.filter do |scope|
+      return nil if file.nil?
+
+      matching_scopes = file.defines_scopes.filter do |scope|
         scope.locations.any? { _1.body.contains?(cursor) }
       end
 
       matching_scopes.last
     end
 
-    def delete_by_fully_qualified_name(fully_qualified_name)
-      table.delete(fully_qualified_name)
-    end
-
     def list_scopes_in_file(file_path)
-      table.filter(:file_paths, file_path).map { _1[:scope] }
+      database.find(file_path)&.defines_scopes || []
     end
   end
 end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope
+  module Store
+    extend self
+
+    def call(database:, parent:, kind:, name:, location:)
+      fully_qualified_name = build_fully_qualified_name(parent:, kind:, name:)
+
+      child_scope = database.find(fully_qualified_name)
+
+      if child_scope.nil?
+        record = Record.new(fully_qualified_name, { fully_qualified_name:, name:, kind:, locations: Location::Collection.new(name) })
+
+        child_scope = database.store(fully_qualified_name, record)
+      end
+
+      child_scope.locations << location
+
+      database.connect(source: parent, target: child_scope, name: :children, inverse_of: :parent)
+      database.connect(source: location.declaration.file, target: child_scope, name: :defines_scopes, inverse_of: :scope_defined_in_file)
+
+      child_scope
+    end
+
+    private
+
+    def build_fully_qualified_name(parent:, kind:, name:)
+      parent_fully_qualified_name =
+        case parent.kind
+        when Kind::ROOT then ""
+        else parent.fully_qualified_name
+        end
+
+      separator =
+        case kind
+        when Kind::INSTANCE_METHOD then "#"
+        when Kind::CLASS_METHOD    then "."
+        else "::"
+        end
+
+      "#{parent_fully_qualified_name}#{separator}#{name}"
+    end
+  end
+end

data/lib/holistic/ruby/type_inference/processing_queue.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Holistic::Ruby::TypeInference::ProcessingQueue
+  def initialize
+    @queue = ::Queue.new
+  end
+
+  def push(reference)
+    @queue.push(reference)
+  end
+
+  def pop
+    @queue.pop(true)
+  end
+
+  def empty?
+    @queue.empty?
+  end
+end

data/lib/holistic/ruby/type_inference/solve.rb

@@ -5,12 +5,13 @@ module Holistic::Ruby::TypeInference
     extend self
 
     def call(application:, reference:)
-      reference.conclusion =
+      referenced_scope =
         solve_scope_reference(application:, reference:) ||
-        solve_method_call(application:, reference:) ||
-        Conclusion.unresolved
+        solve_method_call(application:, reference:)
 
-      application.references.register_reference(reference)
+      if referenced_scope
+        application.database.connect(source: reference, target: referenced_scope, name: :referenced_scope, inverse_of: :referenced_by)
+      end
     end
 
     private
@@ -23,25 +24,21 @@ module Holistic::Ruby::TypeInference
 
       scope_reference_clue = reference.clues.first
 
-      referenced_scope = resolve_scope(
+      resolve_scope(
         application:,
         nesting: scope_reference_clue.nesting,
         resolution_possibilities: scope_reference_clue.resolution_possibilities
       )
-
-      if referenced_scope.present?
-        return Conclusion.done(referenced_scope.fully_qualified_name)
-      end
-
-      nil
     end
 
     SolveMethodCallInCurrentScope = ->(application:, reference:, method_call_clue:) do
-      referenced_method = resolve_method(application:, scope: reference.scope, method_name: method_call_clue.method_name)
+      scope = reference.located_in_scope
 
-      return if referenced_method.nil?
-
-      Conclusion.done(referenced_method.fully_qualified_name)
+      if scope.class_method?
+        resolve_class_method(application:, scope: scope.parent, method_name: method_call_clue.method_name)
+      elsif scope.instance_method? && scope.parent.present?
+        resolve_instance_method(application:, scope: scope.parent, method_name: method_call_clue.method_name)
+      end
     end
 
     SolveMethodCallInSpecifiedScope = ->(application:, reference:, method_call_clue:) do
@@ -53,10 +50,9 @@ module Holistic::Ruby::TypeInference
 
       return if referenced_scope.nil?
 
-      referenced_method = resolve_method(application:, scope: referenced_scope, method_name: method_call_clue.method_name)
-      referenced_method ||= application.extensions.dispatch(:resolve_method_call_known_scope, { reference:, referenced_scope:, method_call_clue: })
+      referenced_method = application.extensions.dispatch(:resolve_method_call_known_scope, { reference:, referenced_scope:, method_call_clue: })
 
-      Conclusion.done(referenced_method.fully_qualified_name) if referenced_method.present?
+      referenced_method || resolve_class_method(application:, scope: referenced_scope, method_name: method_call_clue.method_name)
     end
 
     SolveMethodCallInLocalVariable = ->(application:, reference:, method_call_clue:) do
@@ -93,7 +89,7 @@ module Holistic::Ruby::TypeInference
             "#{resolution_candidate}::#{nesting.to_s}"
           end
 
-        scope = application.scopes.find_by_fully_qualified_name(fully_qualified_scope_name)
+        scope = application.scopes.find(fully_qualified_scope_name)
 
         return scope if scope.present?
       end
@@ -101,10 +97,16 @@ module Holistic::Ruby::TypeInference
       nil
     end
 
-    def resolve_method(application:, scope:, method_name:)
+    def resolve_instance_method(application:, scope:, method_name:)
       method_fully_qualified_name = "#{scope.fully_qualified_name}##{method_name}"
 
-      application.scopes.find_by_fully_qualified_name(method_fully_qualified_name)
+      application.scopes.find(method_fully_qualified_name)
+    end
+
+    def resolve_class_method(application:, scope:, method_name:)
+      method_fully_qualified_name = "#{scope.fully_qualified_name}.#{method_name}"
+
+      application.scopes.find(method_fully_qualified_name)
     end
   end
 end

data/lib/holistic/ruby/type_inference/solve_pending_references.rb

@@ -5,7 +5,9 @@ module Holistic::Ruby::TypeInference
     extend self
 
     def call(application:)
-      application.references.list_references_pending_type_inference_conclusion.each do |reference|
+      until application.type_inference_processing_queue.empty?
+        reference = application.type_inference_processing_queue.pop
+
         Solve.call(application:, reference:)
       end
     end

data/lib/holistic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Holistic
-  VERSION = "0.1.1"
+  VERSION = "0.1.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: holistic-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.6
 platform: ruby
 authors:
 - Luiz Vasconcellos
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-19 00:00:00.000000000 Z
+date: 2023-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: syntax_tree
@@ -73,9 +73,13 @@ files:
 - lib/holistic.rb
 - lib/holistic/application.rb
 - lib/holistic/background_process.rb
+- lib/holistic/database/migrations.rb
+- lib/holistic/database/node.rb
 - lib/holistic/database/table.rb
 - lib/holistic/document/cursor.rb
-- lib/holistic/document/file.rb
+- lib/holistic/document/file/record.rb
+- lib/holistic/document/file/repository.rb
+- lib/holistic/document/file/store.rb
 - lib/holistic/document/location.rb
 - lib/holistic/document/unsaved/change.rb
 - lib/holistic/document/unsaved/collection.rb
@@ -110,23 +114,23 @@ files:
 - lib/holistic/ruby/parser/live_editing/process_file_changed.rb
 - lib/holistic/ruby/parser/nesting_syntax.rb
 - lib/holistic/ruby/parser/program_visitor.rb
-- lib/holistic/ruby/parser/table_of_contents.rb
+- lib/holistic/ruby/reference/delete.rb
 - lib/holistic/ruby/reference/find_referenced_scope.rb
 - lib/holistic/ruby/reference/record.rb
-- lib/holistic/ruby/reference/register.rb
 - lib/holistic/ruby/reference/repository.rb
-- lib/holistic/ruby/reference/unregister.rb
+- lib/holistic/ruby/reference/store.rb
+- lib/holistic/ruby/scope/delete.rb
 - lib/holistic/ruby/scope/kind.rb
+- lib/holistic/ruby/scope/lexical.rb
 - lib/holistic/ruby/scope/list_references.rb
 - lib/holistic/ruby/scope/location.rb
 - lib/holistic/ruby/scope/outline.rb
 - lib/holistic/ruby/scope/record.rb
-- lib/holistic/ruby/scope/register.rb
 - lib/holistic/ruby/scope/repository.rb
-- lib/holistic/ruby/scope/unregister.rb
+- lib/holistic/ruby/scope/store.rb
 - lib/holistic/ruby/type_inference/clue/method_call.rb
 - lib/holistic/ruby/type_inference/clue/scope_reference.rb
-- lib/holistic/ruby/type_inference/conclusion.rb
+- lib/holistic/ruby/type_inference/processing_queue.rb
 - lib/holistic/ruby/type_inference/solve.rb
 - lib/holistic/ruby/type_inference/solve_pending_references.rb
 - lib/holistic/version.rb

data/lib/holistic/document/file.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Holistic::Document
-  class File
-    attr_reader :path
-
-    def initialize(path:)
-      @path = path
-    end
-
-    def read
-      ::File.read(path)
-    end
-
-    def write(content)
-      ::File.write(path, content)
-    end
-
-    class Fake
-      attr_reader :path
-
-      def initialize(path:, content:)
-        @path = path
-        @content = content
-      end
-
-      def read
-        @content
-      end
-
-      def write(content) 
-        @content = content
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Holistic::Ruby::Parser
-  # TODO: move to an attibute of the scope
-  class TableOfContents
-    attr_reader :records
-
-    def initialize
-      @records = Hash.new { |hash, key| hash[key] = {} }
-    end
-
-    def register(scope:, name:, clue:)
-      @records[scope.fully_qualified_name][name] ||= []
-      @records[scope.fully_qualified_name][name] << clue
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Holistic::Ruby::Reference
-  module Register
-    extend self
-
-    def call(repository:, scope:, clues:, location:)
-      conclusion = ::Holistic::Ruby::TypeInference::Conclusion.pending
-
-      reference = ::Holistic::Ruby::Reference::Record.new(scope:, clues:, location:, conclusion:)
-
-      repository.register_reference(reference)
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Holistic::Ruby::Reference
-  module Unregister
-    extend self
-
-    def call(repository:, reference:)
-      repository.delete(reference.identifier)
-    end
-  end
-end