ruby-lsp 0.8.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ed62114ae68bf84cf95f96a2517bc2e729ebaf572500b3871f253bc4b584d7ba
-  data.tar.gz: d34dd2719e3b8088f59f4c38988b3fa7058c866a0d34b8b0b0ea391e18ec64d2
+  metadata.gz: b43407d4d6309c7243a6c69aca8166f6ab3548bd47e939c016efe26c1d8a4a76
+  data.tar.gz: cc5f638aab3322054cc2a09b60fe22a6e5ee8196d88492b4139907c2495c7d5d
 SHA512:
-  metadata.gz: d9d7bdf1a6ce4d3a7711a0032236d25d3b79682239f801354c15c01661a8e3b1110be90dd503e1d75dcd442520893d6cc852ef5a1eaeeb5a0834305a1c3350c7
-  data.tar.gz: f55f82e138cb65fb7450afe86092d294bca06bcd6043439723567ed6538a1b373eed10ba5f3702e9d17f16fc4faa6b5447c048fb5683388e52bea1588d23dc63
+  metadata.gz: dda98d73d8ba39cdfaffa3362177ef96887eccff10332012d43f79bdc78643d3bb79a9e43e05a5c21e4550cf9b86d8d00b5742fb51b124d2ed8c8112bc6f1d1a
+  data.tar.gz: 25a169a3eb717f5f11b5b911c91e11e578d33734f6f616c0c92fd6ebcc89d69ddda6abb13410ef231acc398ba0472e17c778d245b89f1285d64317df98c2299c

data/VERSION

@@ -1 +1 @@
-0.8.0
+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/lib/core_ext/uri.rb

@@ -9,7 +9,7 @@ module URI
       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]:/.match?(path)
+        escaped_path = if /^[A-Z]:/i.match?(path)
           DEFAULT_PARSER.escape("/#{path}")
         else
           DEFAULT_PARSER.escape(path)
@@ -26,20 +26,15 @@ module URI
       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
-      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,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

data/lib/ruby_indexer/test/classes_and_modules_test.rb

@@ -0,0 +1,204 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "test_case"
+
+module RubyIndexer
+  class ClassesAndModulesTest < TestCase
+    def test_empty_statements_class
+      index(<<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_class_with_statements
+      index(<<~RUBY)
+        class Foo
+          def something; end
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:2-2")
+    end
+
+    def test_colon_colon_class
+      index(<<~RUBY)
+        class ::Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_colon_colon_class_inside_class
+      index(<<~RUBY)
+        class Bar
+          class ::Foo
+          end
+        end
+      RUBY
+
+      assert_entry("Bar", Index::Entry::Class, "/fake/path/foo.rb:0-0:3-2")
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:1-2:2-4")
+    end
+
+    def test_namespaced_class
+      index(<<~RUBY)
+        class Foo::Bar
+        end
+      RUBY
+
+      assert_entry("Foo::Bar", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_dynamically_namespaced_class
+      index(<<~RUBY)
+        class self::Bar
+        end
+      RUBY
+
+      refute_entry("self::Bar")
+    end
+
+    def test_empty_statements_module
+      index(<<~RUBY)
+        module Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_module_with_statements
+      index(<<~RUBY)
+        module Foo
+          def something; end
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:2-2")
+    end
+
+    def test_colon_colon_module
+      index(<<~RUBY)
+        module ::Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_namespaced_module
+      index(<<~RUBY)
+        module Foo::Bar
+        end
+      RUBY
+
+      assert_entry("Foo::Bar", Index::Entry::Module, "/fake/path/foo.rb:0-0:1-2")
+    end
+
+    def test_dynamically_namespaced_module
+      index(<<~RUBY)
+        module self::Bar
+        end
+      RUBY
+
+      refute_entry("self::Bar")
+    end
+
+    def test_nested_modules_and_classes
+      index(<<~RUBY)
+        module Foo
+          class Bar
+          end
+
+          module Baz
+            class Qux
+              class Something
+              end
+            end
+          end
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Module, "/fake/path/foo.rb:0-0:10-2")
+      assert_entry("Foo::Bar", Index::Entry::Class, "/fake/path/foo.rb:1-2:2-4")
+      assert_entry("Foo::Baz", Index::Entry::Module, "/fake/path/foo.rb:4-2:9-4")
+      assert_entry("Foo::Baz::Qux", Index::Entry::Class, "/fake/path/foo.rb:5-4:8-6")
+      assert_entry("Foo::Baz::Qux::Something", Index::Entry::Class, "/fake/path/foo.rb:6-6:7-8")
+    end
+
+    def test_deleting_from_index_based_on_file_path
+      index(<<~RUBY)
+        class Foo
+        end
+      RUBY
+
+      assert_entry("Foo", Index::Entry::Class, "/fake/path/foo.rb:0-0:1-2")
+
+      @index.delete("/fake/path/foo.rb")
+      refute_entry("Foo")
+      assert_empty(@index.instance_variable_get(:@files_to_entries))
+    end
+
+    def test_comments_can_be_attached_to_a_class
+      index(<<~RUBY)
+        # This is method comment
+        def foo; end
+        # This is a Foo comment
+        # This is another Foo comment
+        class Foo
+          # This should not be attached
+        end
+
+        # Ignore me
+
+        # This Bar comment has 1 line padding
+
+        class Bar; end
+      RUBY
+
+      foo_entry = @index["Foo"].first
+      assert_equal("# This is a Foo comment\n# This is another Foo comment\n", foo_entry.comments.join)
+
+      bar_entry = @index["Bar"].first
+      assert_equal("# This Bar comment has 1 line padding\n", bar_entry.comments.join)
+    end
+
+    def test_comments_can_be_attached_to_a_namespaced_class
+      index(<<~RUBY)
+        # This is a Foo comment
+        # This is another Foo comment
+        class Foo
+          # This is a Bar comment
+          class Bar; end
+        end
+      RUBY
+
+      foo_entry = @index["Foo"].first
+      assert_equal("# This is a Foo comment\n# This is another Foo comment\n", foo_entry.comments.join)
+
+      bar_entry = @index["Foo::Bar"].first
+      assert_equal("# This is a Bar comment\n", bar_entry.comments.join)
+    end
+
+    def test_comments_can_be_attached_to_a_reopened_class
+      index(<<~RUBY)
+        # This is a Foo comment
+        class Foo; end
+
+        # This is another Foo comment
+        class Foo; end
+      RUBY
+
+      first_foo_entry = @index["Foo"][0]
+      assert_equal("# This is a Foo comment\n", first_foo_entry.comments.join)
+
+      second_foo_entry = @index["Foo"][1]
+      assert_equal("# This is another Foo comment\n", second_foo_entry.comments.join)
+    end
+  end
+end