holistic-ruby 0.1.0

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Reference
+  module FindReferencedScope
+    extend self
+
+    def call(application:, cursor:)
+      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?
+
+      referenced_scope = application.scopes.find_by_fully_qualified_name(reference.conclusion.dependency_identifier)
+
+      [:referenced_scope_found, {reference:, referenced_scope:}]
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Reference
+  Record = ::Struct.new(
+    :scope,
+    :clues,
+    :conclusion,
+    :location,
+    keyword_init: true
+  ) do
+    def identifier = location.identifier
+  end
+end

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

@@ -0,0 +1,15 @@
+# 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/repository.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Reference
+  class Repository
+    attr_reader :table
+
+    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
+      })
+    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)
+      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] }
+    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] }
+      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)
+    end
+
+    concerning :TestHelpers do
+      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 }
+        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 }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# 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/kind.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope
+  module Kind
+    ROOT   = :root
+    MODULE = :module
+    CLASS  = :class
+    METHOD = :method
+    LAMBDA = :lambda
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope
+  module ListReferences
+    extend self
+
+    QueryReferencesRecursively = ->(application, scope) do
+      references_to_scope = application.references.list_references_to(scope.fully_qualified_name)
+
+      references_to_child_scopes = scope.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 ? 1 : 0
+    end
+
+    def call(application:, cursor:)
+      scope = application.scopes.find_by_cursor(cursor)
+
+      return :not_found if scope.nil?
+
+      references = QueryReferencesRecursively.call(application, scope).sort_by(&Relevance)
+
+      [:references_listed, {references:}]
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope
+  class Location
+    class Collection
+      attr_reader :scope, :items
+
+      def initialize(scope, location)
+        raise ::ArgumentError if location.present? && !location.is_a?(Location)
+
+        @scope = scope
+        @items = location.nil? ? [] : [location]
+      end
+
+      def main
+        location_matching_scope_name || items.first
+      end
+
+      delegate :<<,      to: :items
+      delegate :each,    to: :items
+      delegate :map,     to: :items
+      delegate :reject!, to: :items
+      delegate :any?,    to: :items
+
+      private
+
+      def location_matching_scope_name
+        scope_name_in_snake_case = scope.name.underscore
+
+        items.find do |location|
+          ::File.basename(location.declaration.file_path) == "#{scope_name_in_snake_case}.rb"
+        end
+      end
+    end
+
+    attr_reader :declaration, :body
+
+    def initialize(declaration:, body:)
+      @declaration = declaration
+      @body = body
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::Scope
+  module Outline
+    extend self
+
+    Result = ::Struct.new(
+      :declarations,
+      :dependencies,
+      :references,
+      :dependants,
+      keyword_init: true
+    )
+
+    QueryChildScopesRecursively = ->(application, scope) do
+      scope.children + scope.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.eql?(outlined_scope) || scope.descendant?(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? }
+          .reject(&is_local_dependency)
+          .tap { dependencies.concat(_1) }
+      end
+
+      scope.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 }
+
+      references = application.references.list_references_to(scope.fully_qualified_name)
+
+      dependants = references.map { |reference| reference.scope }.uniq
+
+      Result.new(declarations:, dependencies:, references:, dependants:)
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# 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
+  end
+end

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

@@ -0,0 +1,31 @@
+# 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/repository.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+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:
+      })
+    end
+
+    def find_by_fully_qualified_name(fully_qualified_name)
+      table.find(fully_qualified_name).try(:dig, :scope)
+    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) }
+      end
+
+      nil
+    end
+
+    def find_inner_most_scope_by_cursor(cursor)
+      scopes = table.filter(:file_paths, cursor.file_path).map { _1[:scope] }
+
+      matching_scopes = 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] }
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# 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/clue/method_call.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Clue
+  MethodCall = ::Data.define(
+    :nesting,
+    :method_name,
+    :resolution_possibilities
+  ) do
+    def to_s
+      return method_name if nesting.nil?
+
+      "#{nesting}.#{method_name}"
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference::Clue
+  ScopeReference = ::Struct.new(
+    :nesting,
+    :resolution_possibilities,
+    keyword_init: true
+  ) do
+    def to_s
+      nesting.to_s
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# 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

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference
+  module Solve
+    extend self
+
+    def call(application:, reference:)
+      reference.conclusion =
+        solve_scope_reference(application:, reference:) ||
+        solve_method_call(application:, reference:) ||
+        Conclusion.unresolved
+
+      application.references.register_reference(reference)
+    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
+
+      scope_reference_clue = reference.clues.first
+
+      referenced_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)
+
+      return if referenced_method.nil?
+
+      Conclusion.done(referenced_method.fully_qualified_name)
+    end
+
+    SolveMethodCallInSpecifiedScope = ->(application:, reference:, method_call_clue:) do
+      referenced_scope = resolve_scope(
+        application:,
+        nesting: method_call_clue.nesting,
+        resolution_possibilities: method_call_clue.resolution_possibilities
+      )
+
+      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: })
+
+      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
+    end
+
+    def solve_method_call(application:, reference:)
+      has_method_call_clue = reference.clues.one? && reference.clues.first.is_a?(Clue::MethodCall)
+
+      return unless has_method_call_clue
+
+      method_call_clue = reference.clues.first
+
+      if method_call_clue.nesting.nil?
+        SolveMethodCallInCurrentScope.call(application:, reference:, method_call_clue:)
+      elsif method_call_clue.nesting.constant?
+        SolveMethodCallInSpecifiedScope.call(application:, reference:, method_call_clue:)
+      else
+        SolveMethodCallInLocalVariable.call(application:, reference:, method_call_clue:)
+      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_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

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Holistic::Ruby::TypeInference
+  module SolvePendingReferences
+    extend self
+
+    def call(application:)
+      application.references.list_references_pending_type_inference_conclusion.each do |reference|
+        Solve.call(application:, reference:)
+      end
+    end
+  end
+end

data/lib/holistic/version.rb

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

data/lib/holistic.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require "logger"
+
+require "zeitwerk"
+require "syntax_tree"
+
+require "active_support/concern"
+require "active_support/core_ext/module/concerning"
+require "active_support/notifications"
+require "active_support/inflector"
+
+require_relative "../config/logging"
+
+loader = ::Zeitwerk::Loader.for_gem
+loader.setup
+
+module Holistic
+  extend self
+
+  @logger = ::Logger.new(ENV["HOLISTIC_LOG_OUTPUT"])
+  attr_reader :logger
+end
+
+loader.eager_load