spoom 1.1.6 → 1.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e58e5584ba33b3b678ddedb06972121af9dd4b9a8b7f1b6941f6bb939086107a
-  data.tar.gz: c1cc668af1f42ace8318a47ac0b813815e4e6a9ee1d942593b1ff37b9b41cbc2
+  metadata.gz: 54a219cd3c4f0e2ea998e4aa5a81a7556c9aed944fdfe38f6aff1267c421336e
+  data.tar.gz: 10671ff002575fc844189cd4371c8f5c35960fc09c3335e7d3a9a234f89fd4ec
 SHA512:
-  metadata.gz: f389c4b463b7bd1c4a275e844ed68d0d9e7279fefe4b1e9ed29a1c9238c25ad941aa494dee63c4f15dab288602a22efce3da6e7b08c795b1cb99fb236e2edf39
-  data.tar.gz: 7071bc29a1d13087d0e0527832b7619af180b20375c006122d059c640a606a55edd68234e098cf2360f06c00aa165a7a673a4d009275707be830bebef947936a
+  metadata.gz: 3413d1409199b453275c3e41bfa79c4a4b88632d2917c7215eb46812768378a767f6eb9b6b79c3f2eeb7a99d14942bb63c3bdf0f4112cfd8be731ff76706dd06
+  data.tar.gz: 1ccd808b2ed86a945e44c6dc4a5a8bdc231b64eacaa70a3b6a4757b0e415911c9328d70ae148158751e36d320045e8f5d9dc23e4a08aa4305bceb36860f7f346

data/Gemfile

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 source "https://rubygems.org"

data/Rakefile

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 require "bundler/gem_tasks"
 require "rake/testtask"

data/exe/spoom

@@ -1,5 +1,5 @@
 #! /usr/bin/env ruby
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "../lib/spoom"

data/lib/spoom/cli/bump.rb

@@ -83,14 +83,16 @@ module Spoom
           exit(files_to_bump.empty?)
         end
 
-        output, status, exit_code = Sorbet.srb_tc(
+        error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
+        result = Sorbet.srb_tc(
           "--no-error-sections",
+          "--error-url-base=#{error_url_base}",
           path: exec_path,
           capture_err: true,
           sorbet_bin: options[:sorbet]
         )
 
-        check_sorbet_segfault(exit_code) do
+        check_sorbet_segfault(result.exit_code) do
           say_error(<<~ERR, status: nil)
             It means one of the file bumped to `typed: #{to}` made Sorbet crash.
             Run `spoom bump -f` locally followed by `bundle exec srb tc` to investigate the problem.
@@ -98,13 +100,13 @@ module Spoom
           undo_changes(files_to_bump, from)
         end
 
-        if status
+        if result.status
           print_changes(files_to_bump, command: cmd, from: from, to: to, dry: dry, path: exec_path)
           undo_changes(files_to_bump, from) if dry
           exit(files_to_bump.empty?)
         end
 
-        errors = Sorbet::Errors::Parser.parse_string(output)
+        errors = Sorbet::Errors::Parser.parse_string(result.err, error_url_base: error_url_base)
 
         files_with_errors = errors.map do |err|
           path = File.expand_path(err.file)

data/lib/spoom/cli/run.rb

@@ -35,33 +35,33 @@ module Spoom
         sorbet = options[:sorbet]
 
         unless limit || code || sort
-          output, status, exit_code = T.unsafe(Spoom::Sorbet).srb_tc(
+          result = T.unsafe(Spoom::Sorbet).srb_tc(
             *arg,
             path: path,
             capture_err: false,
             sorbet_bin: sorbet
           )
 
-          check_sorbet_segfault(exit_code)
-          say_error(output, status: nil, nl: false)
-          exit(status)
+          check_sorbet_segfault(result.code)
+          say_error(result.err, status: nil, nl: false)
+          exit(result.status)
         end
 
-        output, status, exit_code = T.unsafe(Spoom::Sorbet).srb_tc(
+        result = T.unsafe(Spoom::Sorbet).srb_tc(
           *arg,
           path: path,
           capture_err: true,
           sorbet_bin: sorbet
         )
 
-        check_sorbet_segfault(exit_code)
+        check_sorbet_segfault(result.exit_code)
 
-        if status
-          say_error(output, status: nil, nl: false)
+        if result.status
+          say_error(result.err, status: nil, nl: false)
           exit(0)
         end
 
-        errors = Spoom::Sorbet::Errors::Parser.parse_string(output)
+        errors = Spoom::Sorbet::Errors::Parser.parse_string(result.err)
         errors_count = errors.size
 
         errors = case sort

data/lib/spoom/git.rb

@@ -9,52 +9,58 @@ module Spoom
     extend T::Sig
 
     # Execute a `command`
-    sig { params(command: String, arg: String, path: String).returns([String, String, T::Boolean]) }
+    sig { params(command: String, arg: String, path: String).returns(ExecResult) }
     def self.exec(command, *arg, path: '.')
-      return "", "Error: `#{path}` is not a directory.", false unless File.directory?(path)
-      opts = {}
-      opts[:chdir] = path
-      i, o, e, s = Open3.popen3(*T.unsafe([command, *T.unsafe(arg), opts]))
-      out = o.read.to_s
-      o.close
-      err = e.read.to_s
-      e.close
-      i.close
-      [out, err, s.value.success?]
+      return ExecResult.new(
+        out: "",
+        err: "Error: `#{path}` is not a directory.",
+        status: false,
+        exit_code: 1
+      ) unless File.directory?(path)
+
+      T.unsafe(Open3).popen3(command, *arg, chdir: path) do |_, stdout, stderr, thread|
+        status = T.cast(thread.value, Process::Status)
+        ExecResult.new(
+          out: stdout.read,
+          err: stderr.read,
+          status: T.must(status.success?),
+          exit_code: T.must(status.exitstatus)
+        )
+      end
     end
 
     # Git commands
 
-    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    sig { params(arg: String, path: String).returns(ExecResult) }
     def self.checkout(*arg, path: ".")
       exec("git checkout -q #{arg.join(' ')}", path: path)
     end
 
-    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    sig { params(arg: String, path: String).returns(ExecResult) }
     def self.diff(*arg, path: ".")
       exec("git diff #{arg.join(' ')}", path: path)
     end
 
-    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    sig { params(arg: String, path: String).returns(ExecResult) }
     def self.log(*arg, path: ".")
       exec("git log #{arg.join(' ')}", path: path)
     end
 
-    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    sig { params(arg: String, path: String).returns(ExecResult) }
     def self.rev_parse(*arg, path: ".")
       exec("git rev-parse --short #{arg.join(' ')}", path: path)
     end
 
-    sig { params(arg: String, path: String).returns([String, String, T::Boolean]) }
+    sig { params(arg: String, path: String).returns(ExecResult) }
     def self.show(*arg, path: ".")
       exec("git show #{arg.join(' ')}", path: path)
     end
 
     sig { params(path: String).returns(T.nilable(String)) }
     def self.current_branch(path: ".")
-      out, _, status = exec("git branch --show-current", path: path)
-      return nil unless status
-      out.strip
+      result = exec("git branch --show-current", path: path)
+      return nil unless result.status
+      result.out.strip
     end
 
     # Utils
@@ -62,9 +68,9 @@ module Spoom
     # Get the commit epoch timestamp for a `sha`
     sig { params(sha: String, path: String).returns(T.nilable(Integer)) }
     def self.commit_timestamp(sha, path: ".")
-      out, _, status = show("--no-notes --no-patch --pretty=%at #{sha}", path: path)
-      return nil unless status
-      out.strip.to_i
+      result = show("--no-notes --no-patch --pretty=%at #{sha}", path: path)
+      return nil unless result.status
+      result.out.strip.to_i
     end
 
     # Get the commit Time for a `sha`
@@ -78,9 +84,9 @@ module Spoom
     # Get the last commit sha
     sig { params(path: String).returns(T.nilable(String)) }
     def self.last_commit(path: ".")
-      out, _, status = rev_parse("HEAD", path: path)
-      return nil unless status
-      out.strip
+      result = rev_parse("HEAD", path: path)
+      return nil unless result.status
+      result.out.strip
     end
 
     # Translate a git epoch timestamp into a Time
@@ -92,27 +98,27 @@ module Spoom
     # Is there uncommited changes in `path`?
     sig { params(path: String).returns(T::Boolean) }
     def self.workdir_clean?(path: ".")
-      diff("HEAD", path: path).first.empty?
+      diff("HEAD", path: path).out.empty?
     end
 
     # Get the hash of the commit introducing the `sorbet/config` file
     sig { params(path: String).returns(T.nilable(String)) }
     def self.sorbet_intro_commit(path: ".")
-      res, _, status = Spoom::Git.log("--diff-filter=A --format='%h' -1 -- sorbet/config", path: path)
-      return nil unless status
-      res.strip!
-      return nil if res.empty?
-      res
+      result = Spoom::Git.log("--diff-filter=A --format='%h' -1 -- sorbet/config", path: path)
+      return nil unless result.status
+      out = result.out.strip
+      return nil if out.empty?
+      out
     end
 
     # Get the hash of the commit removing the `sorbet/config` file
     sig { params(path: String).returns(T.nilable(String)) }
     def self.sorbet_removal_commit(path: ".")
-      res, _, status = Spoom::Git.log("--diff-filter=D --format='%h' -1 -- sorbet/config", path: path)
-      return nil unless status
-      res.strip!
-      return nil if res.empty?
-      res
+      result = Spoom::Git.log("--diff-filter=D --format='%h' -1 -- sorbet/config", path: path)
+      return nil unless result.status
+      out = result.out.strip
+      return nil if out.empty?
+      out
     end
   end
 end

data/lib/spoom/sorbet/errors.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Spoom
@@ -6,41 +6,31 @@ module Spoom
     module Errors
       extend T::Sig
 
+      DEFAULT_ERROR_URL_BASE = "https://srb.help/"
+
       # Parse errors from Sorbet output
       class Parser
         extend T::Sig
 
-        HEADER = [
+        HEADER = T.let([
           "👋 Hey there! Heads up that this is not a release build of sorbet.",
           "Release builds are faster and more well-supported by the Sorbet team.",
           "Check out the README to learn how to build Sorbet in release mode.",
           "To forcibly silence this error, either pass --silence-dev-message,",
           "or set SORBET_SILENCE_DEV_MESSAGE=1 in your shell environment.",
-        ]
-
-        ERROR_LINE_MATCH_REGEX = %r{
-          ^         # match beginning of line
-          (\S[^:]*) # capture filename as something that starts with a non-space character
-                    # followed by anything that is not a colon character
-          :         # match the filename - line number seperator
-          (\d+)     # capture the line number
-          :\s       # match the line number - error message separator
-          (.*)      # capture the error message
-          \shttps://srb.help/ # match the error code url prefix
-          (\d+)     # capture the error code
-          $         # match end of line
-        }x.freeze
+        ], T::Array[String])
 
-        sig { params(output: String).returns(T::Array[Error]) }
-        def self.parse_string(output)
-          parser = Spoom::Sorbet::Errors::Parser.new
+        sig { params(output: String, error_url_base: String).returns(T::Array[Error]) }
+        def self.parse_string(output, error_url_base: DEFAULT_ERROR_URL_BASE)
+          parser = Spoom::Sorbet::Errors::Parser.new(error_url_base: error_url_base)
           parser.parse(output)
         end
 
-        sig { void }
-        def initialize
-          @errors = []
-          @current_error = nil
+        sig { params(error_url_base: String).void }
+        def initialize(error_url_base: DEFAULT_ERROR_URL_BASE)
+          @errors = T.let([], T::Array[Error])
+          @error_line_match_regex = T.let(error_line_match_regexp(error_url_base), Regexp)
+          @current_error = T.let(nil, T.nilable(Error))
         end
 
         sig { params(output: String).returns(T::Array[Error]) }
@@ -66,9 +56,26 @@ module Spoom
 
         private
 
+        sig { params(error_url_base: String).returns(Regexp) }
+        def error_line_match_regexp(error_url_base)
+          url = Regexp.escape(error_url_base)
+          %r{
+            ^         # match beginning of line
+            (\S[^:]*) # capture filename as something that starts with a non-space character
+                      # followed by anything that is not a colon character
+            :         # match the filename - line number seperator
+            (\d+)     # capture the line number
+            :\s       # match the line number - error message separator
+            (.*)      # capture the error message
+            \s#{url}  # match the error code url prefix
+            (\d+)     # capture the error code
+            $         # match end of line
+          }x
+        end
+
         sig { params(line: String).returns(T.nilable(Error)) }
         def match_error_line(line)
-          match = line.match(ERROR_LINE_MATCH_REGEX)
+          match = line.match(@error_line_match_regex)
           return unless match
 
           file, line, message, code = match.captures

data/lib/spoom/sorbet/lsp/base.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Spoom
@@ -10,12 +10,17 @@ module Spoom
     #
     # The language server protocol always uses `"2.0"` as the `jsonrpc` version.
     class Message
+      extend T::Sig
+
+      sig { returns(String) }
       attr_reader :jsonrpc
 
+      sig { void }
       def initialize
-        @jsonrpc = '2.0'
+        @jsonrpc = T.let("2.0", String)
       end
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
       def as_json
         instance_variables.each_with_object({}) do |var, obj|
           val = instance_variable_get(var)
@@ -23,8 +28,9 @@ module Spoom
         end
       end
 
+      sig { params(args: T.untyped).returns(String) }
       def to_json(*args)
-        as_json.to_json(*args)
+        T.unsafe(as_json).to_json(*args)
       end
     end
 
@@ -32,8 +38,18 @@ module Spoom
     #
     # Every processed request must send a response back to the sender of the request.
     class Request < Message
-      attr_reader :id, :method, :params
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :id
+
+      sig { returns(String) }
+      attr_reader :method
 
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      attr_reader :params
+
+      sig { params(id: Integer, method: String, params: T::Hash[T.untyped, T.untyped]).void }
       def initialize(id, method, params)
         super()
         @id = id
@@ -46,8 +62,15 @@ module Spoom
     #
     # A processed notification message must not send a response back. They work like events.
     class Notification < Message
-      attr_reader :method, :params
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :method
+
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      attr_reader :params
 
+      sig { params(method: String, params: T::Hash[T.untyped, T.untyped]).void }
       def initialize(method, params)
         super()
         @method = method

data/lib/spoom/sorbet/lsp/errors.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 module Spoom
@@ -8,8 +8,15 @@ module Spoom
       class BadHeaders < Error; end
 
       class Diagnostics < Error
-        attr_reader :uri, :diagnostics
+        extend T::Sig
 
+        sig { returns(String) }
+        attr_reader :uri
+
+        sig { returns(T::Array[Diagnostic]) }
+        attr_reader :diagnostics
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostics) }
         def self.from_json(json)
           Diagnostics.new(
             json['uri'],
@@ -17,6 +24,7 @@ module Spoom
           )
         end
 
+        sig { params(uri: String, diagnostics: T::Array[Diagnostic]).void }
         def initialize(uri, diagnostics)
           @uri = uri
           @diagnostics = diagnostics
@@ -25,8 +33,18 @@ module Spoom
     end
 
     class ResponseError < Error
-      attr_reader :code, :message, :data
+      extend T::Sig
+
+      sig { returns(Integer) }
+      attr_reader :code
+
+      sig { returns(String) }
+      attr_reader :message
+
+      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      attr_reader :data
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(ResponseError) }
       def self.from_json(json)
         ResponseError.new(
           json['code'],
@@ -35,6 +53,7 @@ module Spoom
         )
       end
 
+      sig { params(code: Integer, message: String, data: T::Hash[T.untyped, T.untyped]).void }
       def initialize(code, message, data)
         @code = code
         @message = message

data/lib/spoom/sorbet/lsp/structures.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require_relative "../../printer"
@@ -23,6 +23,7 @@ module Spoom
       const :contents, String
       const :range, T.nilable(Range)
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Hover) }
       def self.from_json(json)
         Hover.new(
           contents: json['contents']['value'],
@@ -36,6 +37,7 @@ module Spoom
         printer.print_object(range) if range
       end
 
+      sig { returns(String) }
       def to_s
         "#{contents} (#{range})."
       end
@@ -48,6 +50,7 @@ module Spoom
       const :line, Integer
       const :char, Integer
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Position) }
       def self.from_json(json)
         Position.new(
           line: json['line'].to_i,
@@ -60,6 +63,7 @@ module Spoom
         printer.print_colored("#{line}:#{char}", Color::LIGHT_BLACK)
       end
 
+      sig { returns(String) }
       def to_s
         "#{line}:#{char}"
       end
@@ -72,6 +76,7 @@ module Spoom
       const :start, Position
       const :end, Position
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Range) }
       def self.from_json(json)
         Range.new(
           start: Position.from_json(json['start']),
@@ -86,6 +91,7 @@ module Spoom
         printer.print_object(self.end)
       end
 
+      sig { returns(String) }
       def to_s
         "#{start}-#{self.end}"
       end
@@ -98,6 +104,7 @@ module Spoom
       const :uri, String
       const :range, LSP::Range
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Location) }
       def self.from_json(json)
         Location.new(
           uri: json['uri'],
@@ -111,6 +118,7 @@ module Spoom
         printer.print_object(range)
       end
 
+      sig { returns(String) }
       def to_s
         "#{uri}:#{range}"
       end
@@ -124,6 +132,7 @@ module Spoom
       const :doc, Object # TODO
       const :params, T::Array[T.untyped] # TODO
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(SignatureHelp) }
       def self.from_json(json)
         SignatureHelp.new(
           label: json['label'],
@@ -140,6 +149,7 @@ module Spoom
         printer.print(")")
       end
 
+      sig { returns(String) }
       def to_s
         "#{label}(#{params})."
       end
@@ -154,6 +164,7 @@ module Spoom
       const :message, String
       const :informations, Object
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostic) }
       def self.from_json(json)
         Diagnostic.new(
           range: Range.from_json(json['range']),
@@ -168,6 +179,7 @@ module Spoom
         printer.print(to_s)
       end
 
+      sig { returns(String) }
       def to_s
         "Error: #{message} (#{code})."
       end
@@ -184,6 +196,7 @@ module Spoom
       const :range, T.nilable(Range)
       const :children, T::Array[DocumentSymbol]
 
+      sig { params(json: T::Hash[T.untyped, T.untyped]).returns(DocumentSymbol) }
       def self.from_json(json)
         DocumentSymbol.new(
           name: json['name'],
@@ -221,16 +234,17 @@ module Spoom
         # TODO: also display details?
       end
 
+      sig { returns(String) }
       def to_s
         "#{name} (#{range})"
       end
 
+      sig { returns(String) }
       def kind_string
-        return "<unknown:#{kind}>" unless SYMBOL_KINDS.key?(kind)
-        SYMBOL_KINDS[kind]
+        SYMBOL_KINDS[kind] || "<unknown:#{kind}>"
       end
 
-      SYMBOL_KINDS = {
+      SYMBOL_KINDS = T.let({
         1 => "file",
         2 => "module",
         3 => "namespace",
@@ -257,13 +271,17 @@ module Spoom
         24 => "event",
         25 => "operator",
         26 => "type_parameter",
-      }
+      }, T::Hash[Integer, String])
     end
 
     class SymbolPrinter < Printer
       extend T::Sig
 
-      attr_accessor :seen, :prefix
+      sig { returns(T::Set[Integer]) }
+      attr_accessor :seen
+
+      sig { returns(T.nilable(String)) }
+      attr_accessor :prefix
 
       sig do
         params(
@@ -275,7 +293,7 @@ module Spoom
       end
       def initialize(out: $stdout, colors: true, indent_level: 0, prefix: nil)
         super(out: out, colors: colors, indent_level: indent_level)
-        @seen = Set.new
+        @seen = T.let(Set.new, T::Set[Integer])
         @out = out
         @colors = colors
         @indent_level = indent_level
@@ -295,6 +313,7 @@ module Spoom
 
       sig { params(uri: String).returns(String) }
       def clean_uri(uri)
+        prefix = self.prefix
         return uri unless prefix
         uri.delete_prefix(prefix)
       end

data/lib/spoom/sorbet/lsp.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require 'open3'
@@ -11,24 +11,35 @@ require_relative 'lsp/errors'
 module Spoom
   module LSP
     class Client
+      extend T::Sig
+
+      sig { params(sorbet_bin: String, sorbet_args: String, path: String).void }
       def initialize(sorbet_bin, *sorbet_args, path: ".")
-        @id = 0
-        @in, @out, @err, @status = T.unsafe(Open3).popen3(sorbet_bin, *sorbet_args, chdir: path)
+        @id = T.let(0, Integer)
+        @open = T.let(false, T::Boolean)
+        io_in, io_out, io_err, _status = T.unsafe(Open3).popen3(sorbet_bin, *sorbet_args, chdir: path)
+        @in = T.let(io_in, IO)
+        @out = T.let(io_out, IO)
+        @err = T.let(io_err, IO)
       end
 
+      sig { returns(Integer) }
       def next_id
         @id += 1
       end
 
+      sig { params(json_string: String).void }
       def send_raw(json_string)
         @in.puts("Content-Length:#{json_string.length}\r\n\r\n#{json_string}")
       end
 
+      sig { params(message: Message).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
       def send(message)
         send_raw(message.to_json)
         read if message.is_a?(Request)
       end
 
+      sig { returns(T.nilable(String)) }
       def read_raw
         header = @out.gets
 
@@ -39,8 +50,12 @@ module Spoom
         @out.read(len + 2) # +2 'cause of the final \r\n
       end
 
+      sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
       def read
-        json = JSON.parse(read_raw)
+        raw_string = read_raw
+        return nil unless raw_string
+
+        json = JSON.parse(raw_string)
 
         # Handle error in the LSP protocol
         raise ResponseError.from_json(json['error']) if json['error']
@@ -53,6 +68,7 @@ module Spoom
 
       # LSP requests
 
+      sig { params(workspace_path: String).void }
       def open(workspace_path)
         raise Error::AlreadyOpen, "Error: CLI already opened" if @open
         send(Request.new(
@@ -68,6 +84,7 @@ module Spoom
         @open = true
       end
 
+      sig { params(uri: String, line: Integer, column: Integer).returns(T.nilable(Hover)) }
       def hover(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -82,10 +99,12 @@ module Spoom
             },
           }
         ))
-        return nil unless json['result']
+
+        return nil unless json && json['result']
         Hover.from_json(json['result'])
       end
 
+      sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[SignatureHelp]) }
       def signatures(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -100,9 +119,12 @@ module Spoom
             },
           }
         ))
+
+        return [] unless json && json['result'] && json['result']['signatures']
         json['result']['signatures'].map { |loc| SignatureHelp.from_json(loc) }
       end
 
+      sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[Location]) }
       def definitions(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -117,9 +139,12 @@ module Spoom
             },
           }
         ))
+
+        return [] unless json && json['result']
         json['result'].map { |loc| Location.from_json(loc) }
       end
 
+      sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[Location]) }
       def type_definitions(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -134,9 +159,12 @@ module Spoom
             },
           }
         ))
+
+        return [] unless json && json['result']
         json['result'].map { |loc| Location.from_json(loc) }
       end
 
+      sig { params(uri: String, line: Integer, column: Integer, include_decl: T::Boolean).returns(T::Array[Location]) }
       def references(uri, line, column, include_decl = true)
         json = send(Request.new(
           next_id,
@@ -154,9 +182,12 @@ module Spoom
             },
           }
         ))
+
+        return [] unless json && json['result']
         json['result'].map { |loc| Location.from_json(loc) }
       end
 
+      sig { params(query: String).returns(T::Array[DocumentSymbol]) }
       def symbols(query)
         json = send(Request.new(
           next_id,
@@ -165,9 +196,12 @@ module Spoom
             'query' => query,
           }
         ))
+
+        return [] unless json && json['result']
         json['result'].map { |loc| DocumentSymbol.from_json(loc) }
       end
 
+      sig { params(uri: String).returns(T::Array[DocumentSymbol]) }
       def document_symbols(uri)
         json = send(Request.new(
           next_id,
@@ -178,14 +212,18 @@ module Spoom
             },
           }
         ))
+
+        return [] unless json && json['result']
         json['result'].map { |loc| DocumentSymbol.from_json(loc) }
       end
 
+      sig { void }
       def close
-        send(Request.new(next_id, "shutdown", nil))
+        send(Request.new(next_id, "shutdown", {}))
         @in.close
         @out.close
         @err.close
+        @open = false
       end
     end
   end

data/lib/spoom/sorbet.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "spoom/sorbet/config"
@@ -12,8 +12,8 @@ require "open3"
 module Spoom
   module Sorbet
     CONFIG_PATH = "sorbet/config"
-    GEM_PATH = Gem::Specification.find_by_name("sorbet-static").full_gem_path
-    BIN_PATH = (Pathname.new(GEM_PATH) / "libexec" / "sorbet").to_s
+    GEM_PATH = T.let(Gem::Specification.find_by_name("sorbet-static").full_gem_path, String)
+    BIN_PATH = T.let((Pathname.new(GEM_PATH) / "libexec" / "sorbet").to_s, String)
 
     SEGFAULT_CODE = 139
 
@@ -26,7 +26,7 @@ module Spoom
           path: String,
           capture_err: T::Boolean,
           sorbet_bin: T.nilable(String)
-        ).returns([String, T::Boolean, Integer])
+        ).returns(ExecResult)
       end
       def srb(*arg, path: '.', capture_err: false, sorbet_bin: nil)
         if sorbet_bin
@@ -34,7 +34,7 @@ module Spoom
         else
           arg.prepend("bundle", "exec", "srb")
         end
-        T.unsafe(Spoom).exec(*arg, path: path, capture_err: capture_err)
+        Spoom.exec(*T.unsafe(arg), path: path, capture_err: capture_err)
       end
 
       sig do
@@ -43,11 +43,11 @@ module Spoom
           path: String,
           capture_err: T::Boolean,
           sorbet_bin: T.nilable(String)
-        ).returns([String, T::Boolean, Integer])
+        ).returns(ExecResult)
       end
       def srb_tc(*arg, path: '.', capture_err: false, sorbet_bin: nil)
         arg.prepend("tc") unless sorbet_bin
-        T.unsafe(self).srb(*arg, path: path, capture_err: capture_err, sorbet_bin: sorbet_bin)
+        srb(*T.unsafe(arg), path: path, capture_err: capture_err, sorbet_bin: sorbet_bin)
       end
 
       # List all files typechecked by Sorbet from its `config`
@@ -69,16 +69,16 @@ module Spoom
         ).returns(T.nilable(String))
       end
       def srb_version(*arg, path: '.', capture_err: false, sorbet_bin: nil)
-        out, res = T.unsafe(self).srb_tc(
+        result = T.let(T.unsafe(self).srb_tc(
           "--no-config",
           "--version",
           *arg,
           path: path,
           capture_err: capture_err,
           sorbet_bin: sorbet_bin
-        )
-        return nil unless res
-        out.split(" ")[2]
+        ), ExecResult)
+        return nil unless result.status
+        result.out.split(" ")[2]
       end
 
       sig do

data/lib/spoom/test_helpers/project.rb

@@ -62,9 +62,9 @@ module Spoom
       # Actions
 
       # Run `git init` in this project
-      sig { void }
-      def git_init
-        Spoom::Git.exec("git init -q", path: path)
+      sig { params(branch: String).void }
+      def git_init(branch: "main")
+        Spoom::Git.exec("git init -q -b #{branch}", path: path)
         Spoom::Git.exec("git config user.name 'spoom-tests'", path: path)
         Spoom::Git.exec("git config user.email 'spoom@shopify.com'", path: path)
       end
@@ -77,21 +77,31 @@ module Spoom
       end
 
       # Run `bundle install` in this project
-      sig { returns([T.nilable(String), T.nilable(String), T::Boolean]) }
+      sig { returns(ExecResult) }
       def bundle_install
         opts = {}
         opts[:chdir] = path
         out, err, status = Open3.capture3("bundle", "install", opts)
-        [out, err, T.must(status.success?)]
+        ExecResult.new(
+          out: out,
+          err: err,
+          status: T.must(status.success?),
+          exit_code: T.must(status.exitstatus)
+        )
       end
 
       # Run a command with `bundle exec` in this project
-      sig { params(cmd: String, args: String).returns([T.nilable(String), T.nilable(String), T::Boolean]) }
+      sig { params(cmd: String, args: String).returns(ExecResult) }
       def bundle_exec(cmd, *args)
         opts = {}
         opts[:chdir] = path
         out, err, status = Open3.capture3(["bundle", "exec", cmd, *args].join(' '), opts)
-        [out, err, T.must(status.success?)]
+        ExecResult.new(
+          out: out,
+          err: err,
+          status: T.must(status.success?),
+          exit_code: T.must(status.exitstatus)
+        )
       end
 
       # Delete this project and its content

data/lib/spoom/timeline.rb

@@ -37,7 +37,7 @@ module Spoom
     sig { params(dates: T::Array[Time]).returns(T::Array[String]) }
     def commits_for_dates(dates)
       dates.map do |t|
-        out, _, _ = Spoom::Git.log(
+        result = Spoom::Git.log(
           "--since='#{t}'",
           "--until='#{t.to_date.next_month}'",
           "--format='format:%h'",
@@ -45,8 +45,8 @@ module Spoom
           "-1",
           path: @path,
         )
-        next if out.empty?
-        out
+        next if result.out.empty?
+        result.out
       end.compact.uniq
     end
   end

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.1.6"
+  VERSION = "1.1.9"
 end

data/lib/spoom.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "sorbet-runtime"
@@ -7,24 +7,42 @@ require "pathname"
 module Spoom
   extend T::Sig
 
-  SPOOM_PATH = (Pathname.new(__FILE__) / ".." / "..").to_s
+  SPOOM_PATH = T.let((Pathname.new(__FILE__) / ".." / "..").to_s, String)
 
   class Error < StandardError; end
 
+  class ExecResult < T::Struct
+    const :out, String
+    const :err, String
+    const :status, T::Boolean
+    const :exit_code, Integer
+  end
+
   sig do
     params(
       cmd: String,
       arg: String,
       path: String,
       capture_err: T::Boolean
-    ).returns([String, T::Boolean, Integer])
+    ).returns(ExecResult)
   end
   def self.exec(cmd, *arg, path: '.', capture_err: false)
-    method = capture_err ? "popen2e" : "popen2"
-    Open3.send(method, [cmd, *arg].join(" "), chdir: path) do |_, stdout, thread|
-      out = stdout.read
-      status = T.cast(thread.value, Process::Status)
-      [out, status.success?, status.exitstatus]
+    if capture_err
+      stdout, stderr, status = T.unsafe(Open3).capture3([cmd, *arg].join(" "), chdir: path)
+      ExecResult.new(
+        out: stdout,
+        err: stderr,
+        status: status.success?,
+        exit_code: status.exitstatus
+      )
+    else
+      stdout, status = T.unsafe(Open3).capture2([cmd, *arg].join(" "), chdir: path)
+      ExecResult.new(
+        out: stdout,
+        err: "",
+        status: status.success?,
+        exit_code: status.exitstatus
+      )
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.1.6
+  version: 1.1.9
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-12-08 00:00:00.000000000 Z
+date: 2022-03-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler