holistic-ruby 0.1.4 → 0.1.7

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

@@ -0,0 +1,29 @@
+# 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)
+
+      reference.relation(:located_in_scope).add!(scope)
+      reference.relation(:reference_defined_in_file).add!(location.file)
+
+      # resolving reference to superclasses need to happen before resolving reference to methods because the
+      # relation ancestor-descentand needs to exist beforehand.
+      # in other words, if we try to resolve a reference to a method *before* resolving the superclass
+      # we might get a miss.
+      should_resolve_type_inference_with_high_priority =
+        reference.find_clue(::Holistic::Ruby::TypeInference::Clue::ReferenceToSuperclass).present?
+
+      if should_resolve_type_inference_with_high_priority
+        processing_queue.push_with_high_priority(reference)
+      else
+        processing_queue.push(reference)
+      end
+    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)
+
+      scope.relation(:scope_defined_in_file).delete!(location_to_remove.declaration.file)
+
+      if scope.locations.empty?
+        scope.relation(:lexical_parent).delete!(scope.lexical_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.lexical_parent
+
+    child_parent.present? && (child_parent == parent || descendant?(child: child_parent, parent:))
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope::ListClassMethods
+  extend self
+
+  def call(scope:)
+    class_methods = scope.lexical_children.filter(&:class_method?)
+    class_method_names = ::Set.new(class_methods.map(&:name))
+
+    ancestor_methods = scope.ancestors.flat_map do |ancestor|
+      ancestor_methods = call(scope: ancestor)
+
+      # reject parent methods that were overriden by the subclass
+      ancestor_methods.reject { |method| class_method_names.include?(method.name) }
+    end
+
+    class_methods + ancestor_methods
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope::ListInstanceMethods
+  extend self
+
+  def call(scope:)
+    instance_methods = scope.lexical_children.filter(&:instance_method?)
+    instance_method_names = ::Set.new(instance_methods.map(&:name))
+
+    ancestor_methods = scope.ancestors.flat_map do |ancestor|
+      ancestor_methods = call(scope: ancestor)
+
+      # reject parent methods that were overriden by the subclass
+      ancestor_methods.reject { |method| instance_method_names.include?(method.name) }
+    end
+
+    instance_methods + ancestor_methods
+  end
+end

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

@@ -5,16 +5,16 @@ 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.to_a
 
-      references_to_child_scopes = scope.children.flat_map { QueryReferencesRecursively.call(application, _1) }
+      references_to_child_scopes = scope.lexical_children.flat_map { QueryReferencesRecursively.call(application, _1) }
 
       references_to_scope + references_to_child_scopes
     end
 
     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

@@ -13,38 +13,38 @@ module Holistic::Ruby::Scope
     )
 
     QueryChildScopesRecursively = ->(application, scope) do
-      scope.children + scope.children.flat_map { QueryChildScopesRecursively[application, _1] }
+      scope.lexical_children.to_a + scope.lexical_children.flat_map { QueryChildScopesRecursively[application, _1] }
     end
 
     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
 
-      scope.children.map(&QueryDependenciesRecursively.curry[application, outlined_scope]).flatten.concat(dependencies)
+      scope.lexical_children.map(&QueryDependenciesRecursively.curry[application, outlined_scope]).flatten.concat(dependencies)
     end
 
     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,26 @@
 # 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))
+  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 lexical_parent   = has_one(:lexical_parent)
+    def lexical_children = has_many(:lexical_children)
+    def ancestors        = has_many(:ancestors)
+    def descendants      = has_many(:descendants)
+    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?
+
+    def inspect
+      "<#{self.class.name} kind=#{kind} fully_qualified_name=#{fully_qualified_name}>"
     end
   end
 end

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

@@ -2,48 +2,51 @@
 
 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)
+
+      return nil if file.nil?
 
-      matching_scopes = scopes.filter do |scope|
-        scope.locations.any? { _1.body.contains?(cursor) }
+      matching_scopes = file.defines_scopes.filter_map do |scope|
+        scope.locations.find { |location| location.body.contains?(cursor) }&.then do |location|
+          { location:, scope: }
+        end
       end
 
-      matching_scopes.last
-    end
+      inner_most_matching_scope = matching_scopes.sort_by { |match| match[:location].declaration.start_line }.last
 
-    def delete_by_fully_qualified_name(fully_qualified_name)
-      table.delete(fully_qualified_name)
+      inner_most_matching_scope&.then { _1[:scope] }
     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:, lexical_parent:, kind:, name:, location:)
+      fully_qualified_name = build_fully_qualified_name(lexical_parent:, kind:, name:)
+
+      scope = database.find(fully_qualified_name)
+
+      if scope.nil?
+        record = Record.new(fully_qualified_name, { fully_qualified_name:, name:, kind:, locations: Location::Collection.new(name) })
+
+        scope = database.store(fully_qualified_name, record)
+      end
+
+      scope.locations << location
+
+      scope.relation(:lexical_parent).add!(lexical_parent)
+      scope.relation(:scope_defined_in_file).add!(location.declaration.file)
+
+      scope
+    end
+
+    private
+
+    def build_fully_qualified_name(lexical_parent:, kind:, name:)
+      parent_fully_qualified_name =
+        case lexical_parent.kind
+        when Kind::ROOT then ""
+        else lexical_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/clue/method_call.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::TypeInference::Clue
+  # TODO: Rename to ReferenceToMethod
   MethodCall = ::Data.define(
     :nesting,
     :method_name,

data/lib/holistic/ruby/type_inference/clue/reference_to_superclass.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Clue
+  ReferenceToSuperclass = ::Data.define(:subclass_scope) do
+    def to_s
+      "superclass of #{subclass_scope.fully_qualified_name}"
+    end
+  end
+end

data/lib/holistic/ruby/type_inference/clue/scope_reference.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module Holistic::Ruby::TypeInference::Clue
+  # TODO: rename to ReferenceToScope
   ScopeReference = ::Struct.new(
     :nesting,
     :resolution_possibilities,

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference
+  class ProcessingQueue
+    def initialize
+      @high_priority_queue = ::Queue.new
+      @queue = ::Queue.new
+    end
+
+    def push(item)
+      @queue.push(item)
+    end
+
+    def push_with_high_priority(item)
+      @high_priority_queue.push(item)
+    end
+
+    def empty?
+      @high_priority_queue.empty? && @queue.empty?
+    end
+
+    def pop
+      return @high_priority_queue.pop if @high_priority_queue.size > 0
+
+      @queue.pop
+    end
+  end
+end

data/lib/holistic/ruby/type_inference/resolver/class_method.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Resolver::ClassMethod
+  extend self
+
+  def resolve(scope:, method_name:)
+    ::Holistic::Ruby::Scope::ListClassMethods.call(scope:).find { _1.name == method_name }
+  end
+end

data/lib/holistic/ruby/type_inference/resolver/instance_method.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Resolver::InstanceMethod
+  extend self
+
+  def resolve(scope:, method_name:)
+    ::Holistic::Ruby::Scope::ListInstanceMethods.call(scope:).find { _1.name == method_name }
+  end
+end

data/lib/holistic/ruby/type_inference/resolver/scope.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Resolver::Scope
+  extend self
+
+  def resolve(application:, nesting:, resolution_possibilities:)
+    resolution_possibilities = ["::"] if nesting.root_scope_resolution?
+
+    resolution_possibilities.each do |resolution_candidate|
+      fully_qualified_scope_name =
+        if resolution_candidate == "::"
+          "::#{nesting.to_s}"
+        else
+          "#{resolution_candidate}::#{nesting.to_s}"
+        end
+
+      scope = application.scopes.find(fully_qualified_scope_name)
+
+      return scope if scope.present?
+    end
+
+    nil
+  end
+end

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

@@ -5,52 +5,47 @@ 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
+        reference.relation(:referenced_scope).add!(referenced_scope)
+
+        # NOTE: should this be an event that is handled by stdlib? I guess inheritance support with dedicated syntax
+        # is part of the language core, so it makes sense being here. Let me think about this for a bit.
+        reference.find_clue(Clue::ReferenceToSuperclass)&.then do |reference_to_superclass_clue|
+          referenced_scope.relation(:descendants).add!(reference_to_superclass_clue.subclass_scope)
+        end
+      end
     end
 
     private
 
     def solve_scope_reference(application:, reference:)
-      has_scope_reference_clue =
-        reference.clues.one? && reference.clues.first.is_a?(Clue::ScopeReference)
-
-      return unless has_scope_reference_clue
+      reference_to_scope_clue = reference.find_clue(Clue::ScopeReference)
 
-      scope_reference_clue = reference.clues.first
+      return if reference_to_scope_clue.nil?
 
-      referenced_scope = resolve_scope(
+      Resolver::Scope.resolve(
         application:,
-        nesting: scope_reference_clue.nesting,
-        resolution_possibilities: scope_reference_clue.resolution_possibilities
+        nesting: reference_to_scope_clue.nesting,
+        resolution_possibilities: reference_to_scope_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
-
-      return if referenced_method.nil?
+      scope = reference.located_in_scope
 
-      Conclusion.done(referenced_method.fully_qualified_name)
+      if scope.class_method?
+        Resolver::ClassMethod.resolve(scope: scope.lexical_parent, method_name: method_call_clue.method_name)
+      elsif scope.instance_method? && scope.lexical_parent.present?
+        Resolver::InstanceMethod.resolve(scope: scope.lexical_parent, method_name: method_call_clue.method_name)
+      end
     end
 
     SolveMethodCallInSpecifiedScope = ->(application:, reference:, method_call_clue:) do
-      referenced_scope = resolve_scope(
+      referenced_scope = Resolver::Scope.resolve(
         application:,
         nesting: method_call_clue.nesting,
         resolution_possibilities: method_call_clue.resolution_possibilities
@@ -59,16 +54,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?
-    end
-
-    SolveMethodCallInLocalVariable = ->(application:, reference:, method_call_clue:) do
-      # local_variable_name = method_call_clue.nesting.to_s
-      # referenced_scope = guess_scope_for_local_variable(scope: reference.scope, name: local_variable_name)
 
-      nil
+      referenced_method || Resolver::ClassMethod.resolve(scope: referenced_scope, method_name: method_call_clue.method_name)
     end
 
     def solve_method_call(application:, reference:)
@@ -83,39 +70,8 @@ module Holistic::Ruby::TypeInference
       elsif method_call_clue.nesting.constant?
         SolveMethodCallInSpecifiedScope.call(application:, reference:, method_call_clue:)
       else
-        SolveMethodCallInLocalVariable.call(application:, reference:, method_call_clue:)
+        nil # TODO
       end
     end
-
-    def resolve_scope(application:, nesting:, resolution_possibilities:)
-      resolution_possibilities = ["::"] if nesting.root_scope_resolution?
-
-      resolution_possibilities.each do |resolution_candidate|
-        fully_qualified_scope_name =
-          if resolution_candidate == "::"
-            "::#{nesting.to_s}"
-          else
-            "#{resolution_candidate}::#{nesting.to_s}"
-          end
-
-        scope = application.scopes.find_by_fully_qualified_name(fully_qualified_scope_name)
-
-        return scope if scope.present?
-      end
-
-      nil
-    end
-
-    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)
-    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)
-    end
   end
 end