ruby-lsp 0.7.6 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a645362acbfb8b0f819bd89fbaf1e53d0f7d9eda81974e62bc0f114aeefc221e
-  data.tar.gz: 861b5c68f9355f551ebfb519507ca1c0028f0e4e2edff70ae6ad62c652bdfd2c
+  metadata.gz: b43407d4d6309c7243a6c69aca8166f6ab3548bd47e939c016efe26c1d8a4a76
+  data.tar.gz: cc5f638aab3322054cc2a09b60fe22a6e5ee8196d88492b4139907c2495c7d5d
 SHA512:
-  metadata.gz: 4283abdb1ce9865e6dbecd0827ddd88f07a63937a9f75ba8ca78142d3536624ac374b165e7a1277adee4197553c74615ed560dad3093eb346ae3e505e174dae5
-  data.tar.gz: 6084fd63d0d780c169b8f8766f347cdb699e2490a0c8de542a3fa969ad37d7f49e281ffa7f92a7ee15a764dccac9832e5e9a49265ba9077f9d204185d0c00e64
+  metadata.gz: dda98d73d8ba39cdfaffa3362177ef96887eccff10332012d43f79bdc78643d3bb79a9e43e05a5c21e4550cf9b86d8d00b5742fb51b124d2ed8c8112bc6f1d1a
+  data.tar.gz: 25a169a3eb717f5f11b5b911c91e11e578d33734f6f616c0c92fd6ebcc89d69ddda6abb13410ef231acc398ba0472e17c778d245b89f1285d64317df98c2299c

data/VERSION

@@ -1 +1 @@
-0.7.6
+0.8.1

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/exe/ruby-lsp-check

@@ -30,13 +30,13 @@ message_queue = Thread::Queue.new
 executor = RubyLsp::Executor.new(store, message_queue)
 
 files.each_with_index do |file, index|
-  uri = "file://#{file}"
+  uri = URI("file://#{file}")
   store.set(uri: uri, source: File.read(file), version: 1)
 
   # Executing any of the automatic requests will execute all of them, so here we just pick one
   result = executor.execute({
     method: "textDocument/documentSymbol",
-    params: { textDocument: { uri: uri } },
+    params: { textDocument: { uri: uri.to_s } },
   })
 
   error = result.error

data/lib/core_ext/uri.rb

@@ -0,0 +1,40 @@
+# typed: strict
+# frozen_string_literal: true
+
+module URI
+  class Generic
+    class << self
+      extend T::Sig
+
+      sig { params(path: String, scheme: String).returns(URI::Generic) }
+      def from_path(path:, 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]:/i.match?(path)
+          DEFAULT_PARSER.escape("/#{path}")
+        else
+          DEFAULT_PARSER.escape(path)
+        end
+
+        build(scheme: scheme, path: escaped_path)
+      end
+    end
+
+    extend T::Sig
+
+    sig { returns(T.nilable(String)) }
+    def to_standardized_path
+      parsed_path = path
+      return unless parsed_path
+
+      unescaped_path = CGI.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
+      if %r{^/[A-Z]:}i.match?(unescaped_path)
+        unescaped_path.delete_prefix("/")
+      else
+        unescaped_path
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# 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,
+      }.freeze,
+      T::Hash[String, T::Class[Object]],
+    )
+
+    sig { void }
+    def initialize
+      development_only_dependencies = Bundler.definition.dependencies.filter_map do |dependency|
+        dependency.name if dependency.groups == [:development]
+      end
+
+      @excluded_gems = T.let(development_only_dependencies, T::Array[String])
+      @included_gems = T.let([], T::Array[String])
+      @excluded_patterns = T.let(["*_test.rb"], T::Array[String])
+      @included_patterns = T.let(["#{Dir.pwd}/**/*.rb"], 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
+      files_to_index = $LOAD_PATH.flat_map { |p| Dir.glob("#{p}/**/*.rb", base: p) }
+
+      @included_patterns.each do |pattern|
+        files_to_index.concat(Dir.glob(pattern, File::FNM_PATHNAME | File::FNM_EXTGLOB))
+      end
+
+      excluded_gem_paths = (@excluded_gems - @included_gems).filter_map do |gem_name|
+        Gem::Specification.find_by_name(gem_name).full_gem_path
+      rescue Gem::MissingSpecError
+        warn("Gem #{gem_name} is excluded in .index.yml, but that gem was not found in the bundle")
+      end
+
+      files_to_index.reject! do |path|
+        @excluded_patterns.any? { |pattern| File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) } ||
+          excluded_gem_paths.any? { |gem_path| File.fnmatch?("#{gem_path}/**/*.rb", path) }
+      end
+      files_to_index.uniq!
+      files_to_index
+    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"]
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RubyIndexer
+  class Index
+    extend T::Sig
+
+    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
+
+    # 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
+    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
+
+      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,121 @@
+# 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::ConstantOperatorOrWriteNode
+        add_constant(node)
+      when YARP::ConstantPathWriteNode, YARP::ConstantPathOperatorOrWriteNode
+        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::ConstantOperatorOrWriteNode),
+      ).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::ConstantPathOperatorOrWriteNode),
+      ).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
+      fully_qualified_name = name.start_with?("::") ? name.delete_prefix("::") : fully_qualify_name(name)
+
+      comments = collect_comments(node)
+      @index << Index::Entry::Constant.new(fully_qualified_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
+
+      fully_qualified_name = name.start_with?("::") ? name : fully_qualify_name(name)
+      name.delete_prefix!("::")
+
+      comments = collect_comments(node)
+      @index << klass.new(fully_qualified_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
+
+        comments.unshift(comment.location.slice)
+      end
+
+      comments
+    end
+
+    sig { params(name: String).returns(String) }
+    def fully_qualify_name(name)
+      return name if @stack.empty?
+
+      "#{@stack.join("::")}::#{name}"
+    end
+  end
+end

data/lib/ruby_indexer/ruby_indexer.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "yaml"
+
+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