ruby-lsp 0.27.0.beta1 → 0.27.0.beta2

data/lib/ruby_indexer/lib/ruby_indexer/reference_finder.rb

@@ -1,335 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyIndexer
-  class ReferenceFinder
-    # @abstract
-    class Target; end
-
-    class ConstTarget < Target
-      #: String
-      attr_reader :fully_qualified_name
-
-      #: (String fully_qualified_name) -> void
-      def initialize(fully_qualified_name)
-        super()
-        @fully_qualified_name = fully_qualified_name
-      end
-    end
-
-    class MethodTarget < Target
-      #: String
-      attr_reader :method_name
-
-      #: (String method_name) -> void
-      def initialize(method_name)
-        super()
-        @method_name = method_name
-      end
-    end
-
-    class InstanceVariableTarget < Target
-      #: String
-      attr_reader :name
-
-      #: Array[String]
-      attr_reader :owner_ancestors
-
-      #: (String name, Array[String] owner_ancestors) -> void
-      def initialize(name, owner_ancestors)
-        super()
-        @name = name
-        @owner_ancestors = owner_ancestors
-      end
-    end
-
-    class Reference
-      #: String
-      attr_reader :name
-
-      #: Prism::Location
-      attr_reader :location
-
-      #: bool
-      attr_reader :declaration
-
-      #: (String name, Prism::Location location, declaration: bool) -> void
-      def initialize(name, location, declaration:)
-        @name = name
-        @location = location
-        @declaration = declaration
-      end
-    end
-
-    #: (Target target, RubyIndexer::Index index, Prism::Dispatcher dispatcher, URI::Generic uri, ?include_declarations: bool) -> void
-    def initialize(target, index, dispatcher, uri, include_declarations: true)
-      @target = target
-      @index = index
-      @uri = uri
-      @include_declarations = include_declarations
-      @stack = [] #: Array[String]
-      @references = [] #: Array[Reference]
-
-      dispatcher.register(
-        self,
-        :on_class_node_enter,
-        :on_class_node_leave,
-        :on_module_node_enter,
-        :on_module_node_leave,
-        :on_singleton_class_node_enter,
-        :on_singleton_class_node_leave,
-        :on_def_node_enter,
-        :on_def_node_leave,
-        :on_multi_write_node_enter,
-        :on_constant_path_write_node_enter,
-        :on_constant_path_or_write_node_enter,
-        :on_constant_path_operator_write_node_enter,
-        :on_constant_path_and_write_node_enter,
-        :on_constant_or_write_node_enter,
-        :on_constant_path_node_enter,
-        :on_constant_read_node_enter,
-        :on_constant_write_node_enter,
-        :on_constant_or_write_node_enter,
-        :on_constant_and_write_node_enter,
-        :on_constant_operator_write_node_enter,
-        :on_instance_variable_read_node_enter,
-        :on_instance_variable_write_node_enter,
-        :on_instance_variable_and_write_node_enter,
-        :on_instance_variable_operator_write_node_enter,
-        :on_instance_variable_or_write_node_enter,
-        :on_instance_variable_target_node_enter,
-        :on_call_node_enter,
-      )
-    end
-
-    #: -> Array[Reference]
-    def references
-      return @references if @include_declarations
-
-      @references.reject(&:declaration)
-    end
-
-    #: (Prism::ClassNode node) -> void
-    def on_class_node_enter(node)
-      @stack << node.constant_path.slice
-    end
-
-    #: (Prism::ClassNode node) -> void
-    def on_class_node_leave(node)
-      @stack.pop
-    end
-
-    #: (Prism::ModuleNode node) -> void
-    def on_module_node_enter(node)
-      @stack << node.constant_path.slice
-    end
-
-    #: (Prism::ModuleNode node) -> void
-    def on_module_node_leave(node)
-      @stack.pop
-    end
-
-    #: (Prism::SingletonClassNode node) -> void
-    def on_singleton_class_node_enter(node)
-      expression = node.expression
-      return unless expression.is_a?(Prism::SelfNode)
-
-      @stack << "<#{@stack.last}>"
-    end
-
-    #: (Prism::SingletonClassNode node) -> void
-    def on_singleton_class_node_leave(node)
-      @stack.pop
-    end
-
-    #: (Prism::ConstantPathNode node) -> void
-    def on_constant_path_node_enter(node)
-      name = Index.constant_name(node)
-      return unless name
-
-      collect_constant_references(name, node.location)
-    end
-
-    #: (Prism::ConstantReadNode node) -> void
-    def on_constant_read_node_enter(node)
-      name = Index.constant_name(node)
-      return unless name
-
-      collect_constant_references(name, node.location)
-    end
-
-    #: (Prism::MultiWriteNode node) -> void
-    def on_multi_write_node_enter(node)
-      [*node.lefts, *node.rest, *node.rights].each do |target|
-        case target
-        when Prism::ConstantTargetNode, Prism::ConstantPathTargetNode
-          collect_constant_references(target.name.to_s, target.location)
-        end
-      end
-    end
-
-    #: (Prism::ConstantPathWriteNode node) -> void
-    def on_constant_path_write_node_enter(node)
-      target = node.target
-      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
-
-      name = Index.constant_name(target)
-      return unless name
-
-      collect_constant_references(name, target.location)
-    end
-
-    #: (Prism::ConstantPathOrWriteNode node) -> void
-    def on_constant_path_or_write_node_enter(node)
-      target = node.target
-      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
-
-      name = Index.constant_name(target)
-      return unless name
-
-      collect_constant_references(name, target.location)
-    end
-
-    #: (Prism::ConstantPathOperatorWriteNode node) -> void
-    def on_constant_path_operator_write_node_enter(node)
-      target = node.target
-      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
-
-      name = Index.constant_name(target)
-      return unless name
-
-      collect_constant_references(name, target.location)
-    end
-
-    #: (Prism::ConstantPathAndWriteNode node) -> void
-    def on_constant_path_and_write_node_enter(node)
-      target = node.target
-      return unless target.parent.nil? || target.parent.is_a?(Prism::ConstantReadNode)
-
-      name = Index.constant_name(target)
-      return unless name
-
-      collect_constant_references(name, target.location)
-    end
-
-    #: (Prism::ConstantWriteNode node) -> void
-    def on_constant_write_node_enter(node)
-      collect_constant_references(node.name.to_s, node.name_loc)
-    end
-
-    #: (Prism::ConstantOrWriteNode node) -> void
-    def on_constant_or_write_node_enter(node)
-      collect_constant_references(node.name.to_s, node.name_loc)
-    end
-
-    #: (Prism::ConstantAndWriteNode node) -> void
-    def on_constant_and_write_node_enter(node)
-      collect_constant_references(node.name.to_s, node.name_loc)
-    end
-
-    #: (Prism::ConstantOperatorWriteNode node) -> void
-    def on_constant_operator_write_node_enter(node)
-      collect_constant_references(node.name.to_s, node.name_loc)
-    end
-
-    #: (Prism::DefNode node) -> void
-    def on_def_node_enter(node)
-      if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
-        @references << Reference.new(name, node.name_loc, declaration: true)
-      end
-
-      if node.receiver.is_a?(Prism::SelfNode)
-        @stack << "<#{@stack.last}>"
-      end
-    end
-
-    #: (Prism::DefNode node) -> void
-    def on_def_node_leave(node)
-      if node.receiver.is_a?(Prism::SelfNode)
-        @stack.pop
-      end
-    end
-
-    #: (Prism::InstanceVariableReadNode node) -> void
-    def on_instance_variable_read_node_enter(node)
-      collect_instance_variable_references(node.name.to_s, node.location, false)
-    end
-
-    #: (Prism::InstanceVariableWriteNode node) -> void
-    def on_instance_variable_write_node_enter(node)
-      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
-    end
-
-    #: (Prism::InstanceVariableAndWriteNode node) -> void
-    def on_instance_variable_and_write_node_enter(node)
-      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
-    end
-
-    #: (Prism::InstanceVariableOperatorWriteNode node) -> void
-    def on_instance_variable_operator_write_node_enter(node)
-      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
-    end
-
-    #: (Prism::InstanceVariableOrWriteNode node) -> void
-    def on_instance_variable_or_write_node_enter(node)
-      collect_instance_variable_references(node.name.to_s, node.name_loc, true)
-    end
-
-    #: (Prism::InstanceVariableTargetNode node) -> void
-    def on_instance_variable_target_node_enter(node)
-      collect_instance_variable_references(node.name.to_s, node.location, true)
-    end
-
-    #: (Prism::CallNode node) -> void
-    def on_call_node_enter(node)
-      if @target.is_a?(MethodTarget) && (name = node.name.to_s) == @target.method_name
-        @references << Reference.new(
-          name,
-          node.message_loc, #: as !nil
-          declaration: false,
-        )
-      end
-    end
-
-    private
-
-    #: (String name, Prism::Location location) -> void
-    def collect_constant_references(name, location)
-      return unless @target.is_a?(ConstTarget)
-
-      entries = @index.resolve(name, @stack)
-      return unless entries
-
-      # Filter down to all constant declarations that match the expected name and type
-      matching_entries = entries.select do |e|
-        [
-          Entry::Namespace,
-          Entry::Constant,
-          Entry::ConstantAlias,
-          Entry::UnresolvedConstantAlias,
-        ].any? { |klass| e.is_a?(klass) } &&
-          e.name == @target.fully_qualified_name
-      end
-
-      return if matching_entries.empty?
-
-      # If any of the matching entries have the same location as the constant and were
-      # defined in the same file, then it is that constant's declaration
-      declaration = matching_entries.any? do |e|
-        e.uri == @uri && e.name_location == location
-      end
-
-      @references << Reference.new(name, location, declaration: declaration)
-    end
-
-    #: (String name, Prism::Location location, bool declaration) -> void
-    def collect_instance_variable_references(name, location, declaration)
-      return unless @target.is_a?(InstanceVariableTarget) && name == @target.name
-
-      receiver_type = Index.actual_nesting(@stack, nil).join("::")
-      if @target.owner_ancestors.include?(receiver_type)
-        @references << Reference.new(name, location, declaration: declaration)
-      end
-    end
-  end
-end

data/lib/ruby_lsp/static_docs.rb

@@ -1,20 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module RubyLsp
-  # The path to the `static_docs` directory, where we keep long-form static documentation
-  STATIC_DOCS_PATH = File.join(
-    File.dirname(
-      File.dirname(
-        __dir__, #: as !nil
-      ),
-    ),
-    "static_docs",
-  ) #: String
-
-  # A map of keyword => short documentation to be displayed on hover or completion
-  KEYWORD_DOCS = {
-    "break" => "Terminates the execution of a block or loop",
-    "yield" => "Invokes the passed block with the given arguments",
-  }.freeze #: Hash[String, String]
-end

data/static_docs/break.md

@@ -1,103 +0,0 @@
-# Break
-
-In Ruby, the `break` keyword is used to exit a loop or block prematurely. Unlike `next` which skips to the next iteration, `break` terminates the loop entirely and continues with the code after the loop.
-
-```ruby
-# Basic break usage in a loop
-5.times do |i|
-  break if i == 3
-
-  puts i
-end
-# Output:
-# 0
-# 1
-# 2
-```
-
-The `break` statement can be used with any of Ruby's iteration methods or loops.
-
-```ruby
-array = [1, 2, 3, 4, 5]
-
-# Break in each iteration
-array.each do |num|
-  break if num > 3
-
-  puts "Number: #{num}"
-end
-# Output:
-# Number: 1
-# Number: 2
-# Number: 3
-
-# Break in an infinite loop
-count = 0
-loop do
-  count += 1
-  break if count >= 3
-
-  puts "Count: #{count}"
-end
-# Output:
-# Count: 1
-# Count: 2
-```
-
-## Break with a Value
-
-When used inside a block, `break` can return a value that becomes the result of the method call.
-
-```ruby
-# Break with a return value in map
-result = [1, 2, 3, 4, 5].map do |num|
-  break "Too large!" if num > 3
-
-  num * 2
-end
-puts result # Output: "Too large!"
-
-# Break with a value in find
-number = (1..10).find do |n|
-  break n if n > 5 && n.even?
-end
-puts number # Output: 6
-```
-
-## Break in Nested Loops
-
-When using `break` in nested loops, it only exits the innermost loop. To break from nested loops, you typically need to use a flag or return.
-
-```ruby
-# Break in nested iteration
-(1..3).each do |i|
-  puts "Outer: #{i}"
-
-  (1..3).each do |j|
-    break if j == 2
-
-    puts "  Inner: #{j}"
-  end
-end
-# Output:
-# Outer: 1
-#   Inner: 1
-# Outer: 2
-#   Inner: 1
-# Outer: 3
-#   Inner: 1
-
-# Breaking from nested loops with a flag
-found = false
-(1..3).each do |i|
-  (1..3).each do |j|
-    if i * j == 4
-      found = true
-      break
-    end
-  end
-  break if found
-end
-```
-
-The `break` keyword is essential for controlling loop execution and implementing early exit conditions. It's particularly useful when you've found what you're looking for and don't need to continue iterating.

data/static_docs/yield.md

@@ -1,81 +0,0 @@
-# Yield
-
-In Ruby, every method implicitly accepts a block, even when not included in the parameters list.
-
-```ruby
-def foo
-end
-
-foo { 123 } # works!
-```
-
-The `yield` keyword is used to invoke the block that was passed with arguments.
-
-```ruby
-# Consider this method call. The block being passed to the method `foo` accepts an argument called `a`.
-# It then takes whatever argument was passed and multiplies it by 2
-foo do |a|
-  a * 2
-end
-
-# In the `foo` method declaration, we can use `yield` to invoke the block that was passed and provide the block
-# with the value for the `a` argument
-def foo
-  # Invoke the block passed to `foo` with the number 10 as the argument `a`
-  result = yield(10)
-  puts result # Will print 20
-end
-```
-
-If `yield` is used to invoke the block, but no block was passed, that will result in a local jump error.
-
-```ruby
-# If we invoke `foo` without a block, trying to `yield` will fail
-foo
-
-# `foo': no block given (yield) (LocalJumpError)
-```
-
-We can decide to use `yield` conditionally by using Ruby's `block_given?` method, which will return `true` if a block
-was passed to the method.
-
-```ruby
-def foo
-  # If a block is passed when invoking `foo`, call the block with argument 10 and print the result.
-  # Otherwise, just print that no block was passed
-  if block_given?
-    result = yield(10)
-    puts result
-  else
-    puts "No block passed!"
-  end
-end
-
-foo do |a|
-  a * 2
-end
-# => 20
-
-foo
-# => No block passed!
-```
-
-## Block parameter
-
-In addition to implicit blocks, Ruby also allows developers to use explicit block parameters as part of the method's
-signature. In this scenario, we can use the reference to the block directly instead of relying on the `yield` keyword.
-
-```ruby
-# Block parameters are prefixed with & and a name
-def foo(&my_block_param)
-  # If a block was passed to `foo`, `my_block_param` will be a `Proc` object. Otherwise, it will be `nil`. We can use
-  # that to check for its presence
-  if my_block_param
-    # Explicit block parameters are invoked using the method `call`, which is present in all `Proc` objects
-    result = my_block_param.call(10)
-    puts result
-  else
-    puts "No block passed!"
-  end
-end
-```