ruby-lsp 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed62114ae68bf84cf95f96a2517bc2e729ebaf572500b3871f253bc4b584d7ba
-  data.tar.gz: d34dd2719e3b8088f59f4c38988b3fa7058c866a0d34b8b0b0ea391e18ec64d2
+  metadata.gz: 3dd7fa2d26430cf1974e1d94bbfa860166dd964ffe9268d9b307b323baa86954
+  data.tar.gz: 6183306fd3d34396de880184fe9a09cdafccd6cb071b7927e458f658d9397221
 SHA512:
-  metadata.gz: d9d7bdf1a6ce4d3a7711a0032236d25d3b79682239f801354c15c01661a8e3b1110be90dd503e1d75dcd442520893d6cc852ef5a1eaeeb5a0834305a1c3350c7
-  data.tar.gz: f55f82e138cb65fb7450afe86092d294bca06bcd6043439723567ed6538a1b373eed10ba5f3702e9d17f16fc4faa6b5447c048fb5683388e52bea1588d23dc63
+  metadata.gz: ed5e0524b0001497cd857dad621a6b072434375ef2be8583e12ddfcd2b7d104b279ab7ea026db09e563ddd908d7d575da682bf6a30244cd6aca68da6b4ee2ad6
+  data.tar.gz: 8de1bdb11dfb12c34129e3fddeae89c6b3700a74cb6483424523df9584a28a8b52499fade45d7c7c047ee517ed53a5a4f54b9fcc04a386a17b092999a264563a

data/VERSION

@@ -1 +1 @@
-0.8.0
+0.9.0

data/exe/ruby-lsp

@@ -1,6 +1,46 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
+require "optparse"
+
+options = {}
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: ruby-lsp [options]"
+
+  opts.on("--version", "Print ruby-lsp version") do
+    require "ruby-lsp"
+    puts RubyLsp::VERSION
+    exit(0)
+  end
+
+  opts.on("--debug", "Launch the Ruby LSP with a debugger attached") do
+    options[:debug] = true
+  end
+
+  opts.on(
+    "--branch [BRANCH]",
+    "Launch the Ruby LSP using the specified branch rather than the release version",
+  ) do |branch|
+    options[:branch] = branch
+  end
+
+  opts.on("-h", "--help", "Print this help") do
+    puts opts.help
+    puts
+    puts "See https://shopify.github.io/ruby-lsp/ for more information"
+    exit(0)
+  end
+end
+
+begin
+  parser.parse
+rescue OptionParser::InvalidOption => e
+  warn(e)
+  warn("")
+  warn(parser.help)
+  exit(1)
+end
+
 # When we're running without bundler, then we need to make sure the custom bundle is fully configured and re-execute
 # using `BUNDLE_GEMFILE=.ruby-lsp/Gemfile bundle exec ruby-lsp` so that we have access to the gems that are a part of
 # the application's bundle
@@ -8,7 +48,7 @@ if ENV["BUNDLE_GEMFILE"].nil?
   require_relative "../lib/ruby_lsp/setup_bundler"
 
   begin
-    bundle_gemfile, bundle_path = RubyLsp::SetupBundler.new(Dir.pwd).setup!
+    bundle_gemfile, bundle_path = RubyLsp::SetupBundler.new(Dir.pwd, branch: options[:branch]).setup!
   rescue RubyLsp::SetupBundler::BundleNotLocked
     warn("Project contains a Gemfile, but no Gemfile.lock. Run `bundle install` to lock gems and restart the server")
     exit(78)
@@ -38,38 +78,6 @@ end
 
 require_relative "../lib/ruby_lsp/internal"
 
-require "optparse"
-
-options = {}
-parser = OptionParser.new do |opts|
-  opts.banner = "Usage: ruby-lsp [options]"
-
-  opts.on("--version", "Print ruby-lsp version") do
-    puts RubyLsp::VERSION
-    exit(0)
-  end
-
-  opts.on("--debug", "Launch the Ruby LSP with a debugger attached") do
-    options[:debug] = true
-  end
-
-  opts.on("-h", "--help", "Print this help") do
-    puts opts.help
-    puts
-    puts "See https://shopify.github.io/ruby-lsp/ for more information"
-    exit(0)
-  end
-end
-
-begin
-  parser.parse!
-rescue OptionParser::InvalidOption => e
-  warn(e)
-  warn("")
-  warn(parser.help)
-  exit(1)
-end
-
 if options[:debug]
   if ["x64-mingw-ucrt", "x64-mingw32"].include?(RUBY_PLATFORM)
     puts "Debugging is not supported on Windows"

data/lib/core_ext/uri.rb

@@ -6,16 +6,16 @@ module URI
     class << self
       extend T::Sig
 
-      sig { params(path: String, scheme: String).returns(URI::Generic) }
-      def from_path(path:, scheme: "file")
+      sig { params(path: String, fragment: T.nilable(String), scheme: String).returns(URI::Generic) }
+      def from_path(path:, fragment: nil, scheme: "file")
         # On Windows, if the path begins with the disk name, we need to add a leading slash to make it a valid URI
-        escaped_path = if /^[A-Z]:/.match?(path)
+        escaped_path = if /^[A-Z]:/i.match?(path)
           DEFAULT_PARSER.escape("/#{path}")
         else
           DEFAULT_PARSER.escape(path)
         end
 
-        build(scheme: scheme, path: escaped_path)
+        build(scheme: scheme, path: escaped_path, fragment: fragment)
       end
     end
 
@@ -26,20 +26,15 @@ module URI
       parsed_path = path
       return unless parsed_path
 
+      unescaped_path = DEFAULT_PARSER.unescape(parsed_path)
+
       # On Windows, when we're getting the file system path back from the URI, we need to remove the leading forward
       # slash
-      actual_path = if %r{^/[A-Z]:}.match?(parsed_path)
-        parsed_path.delete_prefix("/")
+      if %r{^/[A-Z]:}i.match?(unescaped_path)
+        unescaped_path.delete_prefix("/")
       else
-        parsed_path
+        unescaped_path
       end
-
-      CGI.unescape(actual_path)
-    end
-
-    sig { returns(String) }
-    def storage_key
-      T.must(to_standardized_path || opaque)
     end
   end
 end

data/lib/ruby_indexer/lib/ruby_indexer/configuration.rb

@@ -0,0 +1,166 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class Configuration
+    extend T::Sig
+
+    CONFIGURATION_SCHEMA = T.let(
+      {
+        "excluded_gems" => Array,
+        "included_gems" => Array,
+        "excluded_patterns" => Array,
+        "included_patterns" => Array,
+        "excluded_magic_comments" => Array,
+      }.freeze,
+      T::Hash[String, T.untyped],
+    )
+
+    sig { void }
+    def initialize
+      excluded_gem_names = Bundler.definition.dependencies.filter_map do |dependency|
+        dependency.name if dependency.groups == [:development]
+      end
+
+      @excluded_gems = T.let(excluded_gem_names, T::Array[String])
+      @included_gems = T.let([], T::Array[String])
+      @excluded_patterns = T.let(["**/*_test.rb"], T::Array[String])
+      path = Bundler.settings["path"]
+      @excluded_patterns << "#{File.expand_path(path, Dir.pwd)}/**/*.rb" if path
+
+      @included_patterns = T.let(["#{Dir.pwd}/**/*.rb"], T::Array[String])
+      @excluded_magic_comments = T.let(
+        [
+          "frozen_string_literal:",
+          "typed:",
+          "compiled:",
+          "encoding:",
+          "shareable_constant_value:",
+          "warn_indent:",
+          "rubocop:",
+          "nodoc:",
+          "doc:",
+          "coding:",
+          "warn_past_scope:",
+        ],
+        T::Array[String],
+      )
+    end
+
+    sig { void }
+    def load_config
+      return unless File.exist?(".index.yml")
+
+      config = YAML.parse_file(".index.yml")
+      return unless config
+
+      config_hash = config.to_ruby
+      validate_config!(config_hash)
+      apply_config(config_hash)
+    rescue Psych::SyntaxError => e
+      raise e, "Syntax error while loading .index.yml configuration: #{e.message}"
+    end
+
+    sig { returns(T::Array[String]) }
+    def files_to_index
+      excluded_gems = @excluded_gems - @included_gems
+      locked_gems = Bundler.locked_gems&.specs
+
+      # NOTE: indexing the patterns (both included and excluded) needs to happen before indexing gems, otherwise we risk
+      # having duplicates if BUNDLE_PATH is set to a folder inside the project structure
+
+      # Add user specified patterns
+      files_to_index = @included_patterns.flat_map do |pattern|
+        Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      end
+
+      # Remove user specified patterns
+      files_to_index.reject! do |path|
+        @excluded_patterns.any? do |pattern|
+          File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+        end
+      end
+
+      # Add default gems to the list of files to be indexed
+      Dir.glob("#{RbConfig::CONFIG["rubylibdir"]}/*").each do |default_path|
+        # The default_path might be a Ruby file or a folder with the gem's name. For example:
+        #   bundler/
+        #   bundler.rb
+        #   psych/
+        #   psych.rb
+        pathname = Pathname.new(default_path)
+        short_name = pathname.basename.to_s.delete_suffix(".rb")
+
+        # If the gem name is excluded, then we skip it
+        next if excluded_gems.include?(short_name)
+
+        # If the default gem is also a part of the bundle, we skip indexing the default one and index only the one in
+        # the bundle, which won't be in `default_path`, but will be in `Bundler.bundle_path` instead
+        next if locked_gems&.any? do |locked_spec|
+          locked_spec.name == short_name &&
+            !Gem::Specification.find_by_name(short_name).full_gem_path.start_with?(RbConfig::CONFIG["rubylibprefix"])
+        end
+
+        if pathname.directory?
+          # If the default_path is a directory, we index all the Ruby files in it
+          files_to_index.concat(Dir.glob("#{default_path}/**/*.rb", File::FNM_PATHNAME | File::FNM_EXTGLOB))
+        else
+          # If the default_path is a Ruby file, we index it
+          files_to_index << default_path
+        end
+      end
+
+      # Add the locked gems to the list of files to be indexed
+      locked_gems&.each do |lazy_spec|
+        next if excluded_gems.include?(lazy_spec.name)
+
+        spec = Gem::Specification.find_by_name(lazy_spec.name)
+
+        # When working on a gem, it will be included in the locked_gems list. Since these are the project's own files,
+        # we have already included and handled exclude patterns for it and should not re-include or it'll lead to
+        # duplicates or accidentally ignoring exclude patterns
+        next if spec.full_gem_path == Dir.pwd
+
+        files_to_index.concat(Dir.glob("#{spec.full_gem_path}/{#{spec.require_paths.join(",")}}/**/*.rb"))
+      rescue Gem::MissingSpecError
+        # If a gem is scoped only to some specific platform, then its dependencies may not be installed either, but they
+        # are still listed in locked_gems. We can't index them because they are not installed for the platform, so we
+        # just ignore if they're missing
+      end
+
+      files_to_index.uniq!
+      files_to_index
+    end
+
+    sig { returns(Regexp) }
+    def magic_comment_regex
+      /^\s*#\s*#{@excluded_magic_comments.join("|")}/
+    end
+
+    private
+
+    sig { params(config: T::Hash[String, T.untyped]).void }
+    def validate_config!(config)
+      errors = config.filter_map do |key, value|
+        type = CONFIGURATION_SCHEMA[key]
+
+        if type.nil?
+          "Unknown configuration option: #{key}"
+        elsif !value.is_a?(type)
+          "Expected #{key} to be a #{type}, but got #{value.class}"
+        end
+      end
+
+      raise ArgumentError, errors.join("\n") if errors.any?
+    end
+
+    sig { params(config: T::Hash[String, T.untyped]).void }
+    def apply_config(config)
+      @excluded_gems.concat(config["excluded_gems"]) if config["excluded_gems"]
+      @included_gems.concat(config["included_gems"]) if config["included_gems"]
+      @excluded_patterns.concat(config["excluded_patterns"]) if config["excluded_patterns"]
+      @included_patterns.concat(config["included_patterns"]) if config["included_patterns"]
+      @excluded_magic_comments.concat(config["excluded_magic_comments"]) if config["excluded_magic_comments"]
+    end
+  end
+end

data/lib/ruby_indexer/lib/ruby_indexer/index.rb

@@ -0,0 +1,147 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class Index
+    extend T::Sig
+
+    # The minimum Jaro-Winkler similarity score for an entry to be considered a match for a given fuzzy search query
+    ENTRY_SIMILARITY_THRESHOLD = 0.7
+
+    sig { void }
+    def initialize
+      # Holds all entries in the index using the following format:
+      # {
+      #  "Foo" => [#<Entry::Class>, #<Entry::Class>],
+      #  "Foo::Bar" => [#<Entry::Class>],
+      # }
+      @entries = T.let({}, T::Hash[String, T::Array[Entry]])
+
+      # Holds references to where entries where discovered so that we can easily delete them
+      # {
+      #  "/my/project/foo.rb" => [#<Entry::Class>, #<Entry::Class>],
+      #  "/my/project/bar.rb" => [#<Entry::Class>],
+      # }
+      @files_to_entries = T.let({}, T::Hash[String, T::Array[Entry]])
+    end
+
+    sig { params(path: String).void }
+    def delete(path)
+      # For each constant discovered in `path`, delete the associated entry from the index. If there are no entries
+      # left, delete the constant from the index.
+      @files_to_entries[path]&.each do |entry|
+        entries = @entries[entry.name]
+        next unless entries
+
+        # Delete the specific entry from the list for this name
+        entries.delete(entry)
+        # If all entries were deleted, then remove the name from the hash
+        @entries.delete(entry.name) if entries.empty?
+      end
+
+      @files_to_entries.delete(path)
+    end
+
+    sig { params(entry: Entry).void }
+    def <<(entry)
+      (@entries[entry.name] ||= []) << entry
+      (@files_to_entries[entry.file_path] ||= []) << entry
+    end
+
+    sig { params(fully_qualified_name: String).returns(T.nilable(T::Array[Entry])) }
+    def [](fully_qualified_name)
+      @entries[fully_qualified_name.delete_prefix("::")]
+    end
+
+    # Fuzzy searches index entries based on Jaro-Winkler similarity. If no query is provided, all entries are returned
+    sig { params(query: T.nilable(String)).returns(T::Array[Entry]) }
+    def fuzzy_search(query)
+      return @entries.flat_map { |_name, entries| entries } unless query
+
+      normalized_query = query.gsub("::", "").downcase
+
+      results = @entries.filter_map do |name, entries|
+        similarity = DidYouMean::JaroWinkler.distance(name.gsub("::", "").downcase, normalized_query)
+        [entries, -similarity] if similarity > ENTRY_SIMILARITY_THRESHOLD
+      end
+      results.sort_by!(&:last)
+      results.flat_map(&:first)
+    end
+
+    # Try to find the entry based on the nesting from the most specific to the least specific. For example, if we have
+    # the nesting as ["Foo", "Bar"] and the name as "Baz", we will try to find it in this order:
+    # 1. Foo::Bar::Baz
+    # 2. Foo::Baz
+    # 3. Baz
+    sig { params(name: String, nesting: T::Array[String]).returns(T.nilable(T::Array[Entry])) }
+    def resolve(name, nesting)
+      (nesting.length + 1).downto(0).each do |i|
+        prefix = T.must(nesting[0...i]).join("::")
+        full_name = prefix.empty? ? name : "#{prefix}::#{name}"
+        entries = @entries[full_name]
+        return entries if entries
+      end
+
+      nil
+    end
+
+    sig { params(paths: T::Array[String]).void }
+    def index_all(paths: RubyIndexer.configuration.files_to_index)
+      paths.each { |path| index_single(path) }
+    end
+
+    sig { params(path: String, source: T.nilable(String)).void }
+    def index_single(path, source = nil)
+      content = source || File.read(path)
+      visitor = IndexVisitor.new(self, YARP.parse(content), path)
+      visitor.run
+    rescue Errno::EISDIR
+      # If `path` is a directory, just ignore it and continue indexing
+    end
+
+    class Entry
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { returns(String) }
+      attr_reader :file_path
+
+      sig { returns(YARP::Location) }
+      attr_reader :location
+
+      sig { returns(T::Array[String]) }
+      attr_reader :comments
+
+      sig { params(name: String, file_path: String, location: YARP::Location, comments: T::Array[String]).void }
+      def initialize(name, file_path, location, comments)
+        @name = name
+        @file_path = file_path
+        @location = location
+        @comments = comments
+      end
+
+      sig { returns(String) }
+      def file_name
+        File.basename(@file_path)
+      end
+
+      class Namespace < Entry
+        sig { returns(String) }
+        def short_name
+          T.must(@name.split("::").last)
+        end
+      end
+
+      class Module < Namespace
+      end
+
+      class Class < Namespace
+      end
+
+      class Constant < Entry
+      end
+    end
+  end
+end

data/lib/ruby_indexer/lib/ruby_indexer/visitor.rb

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class IndexVisitor < YARP::Visitor
+    extend T::Sig
+
+    sig { params(index: Index, parse_result: YARP::ParseResult, file_path: String).void }
+    def initialize(index, parse_result, file_path)
+      @index = index
+      @parse_result = parse_result
+      @file_path = file_path
+      @stack = T.let([], T::Array[String])
+      @comments_by_line = T.let(
+        parse_result.comments.to_h do |c|
+          [c.location.start_line, c]
+        end,
+        T::Hash[Integer, YARP::Comment],
+      )
+
+      super()
+    end
+
+    sig { void }
+    def run
+      visit(@parse_result.value)
+    end
+
+    sig { params(node: T.nilable(YARP::Node)).void }
+    def visit(node)
+      case node
+      when YARP::ProgramNode, YARP::StatementsNode
+        visit_child_nodes(node)
+      when YARP::ClassNode
+        add_index_entry(node, Index::Entry::Class)
+      when YARP::ModuleNode
+        add_index_entry(node, Index::Entry::Module)
+      when YARP::ConstantWriteNode, YARP::ConstantOrWriteNode
+        add_constant(node)
+      when YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode
+        add_constant_with_path(node)
+      end
+    end
+
+    # Override to avoid using `map` instead of `each`
+    sig { params(nodes: T::Array[T.nilable(YARP::Node)]).void }
+    def visit_all(nodes)
+      nodes.each { |node| visit(node) }
+    end
+
+    private
+
+    sig do
+      params(
+        node: T.any(YARP::ConstantWriteNode, YARP::ConstantOrWriteNode),
+      ).void
+    end
+    def add_constant(node)
+      comments = collect_comments(node)
+      @index << Index::Entry::Constant.new(fully_qualify_name(node.name), @file_path, node.location, comments)
+    end
+
+    sig do
+      params(
+        node: T.any(YARP::ConstantPathWriteNode, YARP::ConstantPathOrWriteNode),
+      ).void
+    end
+    def add_constant_with_path(node)
+      # ignore variable constants like `var::FOO` or `self.class::FOO`
+      return unless node.target.parent.nil? || node.target.parent.is_a?(YARP::ConstantReadNode)
+
+      name = node.target.location.slice
+      comments = collect_comments(node)
+      @index << Index::Entry::Constant.new(fully_qualify_name(name), @file_path, node.location, comments)
+    end
+
+    sig { params(node: T.any(YARP::ClassNode, YARP::ModuleNode), klass: T.class_of(Index::Entry)).void }
+    def add_index_entry(node, klass)
+      name = node.constant_path.location.slice
+
+      unless /^[A-Z:]/.match?(name)
+        return visit_child_nodes(node)
+      end
+
+      comments = collect_comments(node)
+      @index << klass.new(fully_qualify_name(name), @file_path, node.location, comments)
+      @stack << name
+      visit_child_nodes(node)
+      @stack.pop
+    end
+
+    sig { params(node: YARP::Node).returns(T::Array[String]) }
+    def collect_comments(node)
+      comments = []
+
+      start_line = node.location.start_line - 1
+      start_line -= 1 unless @comments_by_line.key?(start_line)
+
+      start_line.downto(1) do |line|
+        comment = @comments_by_line[line]
+        break unless comment
+
+        comment_content = comment.location.slice.chomp
+        next if comment_content.match?(RubyIndexer.configuration.magic_comment_regex)
+
+        comment_content.delete_prefix!("#")
+        comment_content.delete_prefix!(" ")
+        comments.unshift(comment_content)
+      end
+
+      comments
+    end
+
+    sig { params(name: String).returns(String) }
+    def fully_qualify_name(name)
+      if @stack.empty? || name.start_with?("::")
+        name
+      else
+        "#{@stack.join("::")}::#{name}"
+      end.delete_prefix("::")
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "yaml"
+require "did_you_mean"
+
+require "ruby_indexer/lib/ruby_indexer/visitor"
+require "ruby_indexer/lib/ruby_indexer/index"
+require "ruby_indexer/lib/ruby_indexer/configuration"
+
+module RubyIndexer
+  class << self
+    extend T::Sig
+
+    sig { returns(Configuration) }
+    def configuration
+      @configuration ||= T.let(Configuration.new, T.nilable(Configuration))
+    end
+  end
+end