holistic-ruby 0.1.4 → 0.1.6

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,30 +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 = 
-        if reference.scope.class_method?
-          resolve_class_method(application:, scope: reference.scope.parent, method_name: method_call_clue.method_name)
-        elsif reference.scope.instance_method? && reference.scope.parent.present?
-          resolve_instance_method(application:, scope: reference.scope.parent, method_name: method_call_clue.method_name)
-        end
+      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
@@ -59,9 +51,8 @@ module Holistic::Ruby::TypeInference
       return if referenced_scope.nil?
 
       referenced_method = application.extensions.dispatch(:resolve_method_call_known_scope, { reference:, referenced_scope:, method_call_clue: })
-      referenced_method ||= resolve_class_method(application:, scope: referenced_scope, method_name: method_call_clue.method_name)
 
-      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
@@ -98,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
@@ -109,13 +100,13 @@ module Holistic::Ruby::TypeInference
     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_by_fully_qualified_name(method_fully_qualified_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.4"
+  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.4
+  version: 0.1.6
 platform: ruby
 authors:
 - Luiz Vasconcellos
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-20 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

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Holistic::Ruby::Scope
-  module Register
-    extend self
-
-    def call(repository:, parent:, kind:, name:, location:)
-      child_scope = append_location_to_existing_scope(scope: parent, name:, location:) || add_new_scope(parent:, kind:, name:, location:)
-
-      repository.register_scope(child_scope)
-
-      child_scope
-    end
-
-    private
-
-    def append_location_to_existing_scope(scope:, name:, location:)
-      child_scope = scope.children.find { _1.name == name }
-
-      return if child_scope.nil?
-
-      child_scope.tap { _1.locations << location }
-    end
-
-    def add_new_scope(parent:, kind:, name:, location:)
-      child_scope = Record.new(kind:, name:, parent:, location:)
-
-      child_scope.tap { parent.children << _1 }
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module Holistic::Ruby::Scope
-  module Unregister
-    extend self
-
-    def call(repository:, fully_qualified_name:, file_path:)
-      scope = repository.find_by_fully_qualified_name(fully_qualified_name)
-
-      return :scope_not_found if scope.nil?
-
-      updated_locations = scope.locations.reject! { |scope_location| scope_location.declaration.file_path == file_path }
-
-      return :scope_not_defined_in_speciefied_file if updated_locations.nil?
-
-      if updated_locations.empty?
-        scope.parent.children.delete(scope)
-
-        repository.delete_by_fully_qualified_name(fully_qualified_name)
-      else
-        repository.register_scope(scope)
-      end
-
-      :definition_unregistered
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Holistic::Ruby::TypeInference
-  STATUS_PENDING = :pending
-  STATUS_DONE    = :done
-
-  Conclusion = ::Data.define(:status, :dependency_identifier) do
-    def self.pending
-      new(status: STATUS_PENDING, dependency_identifier: nil)
-    end
-
-    def self.unresolved
-      new(status: STATUS_DONE, dependency_identifier: nil)
-    end
-
-    def self.done(dependency_identifier)
-      new(status: STATUS_DONE, dependency_identifier:)
-    end
-  end
-end