spoom 1.5.4 → 1.6.0

data/lib/spoom/sorbet/errors.rb

@@ -7,17 +7,13 @@ module Spoom
       DEFAULT_ERROR_URL_BASE = "https://srb.help/"
 
       class << self
-        extend T::Sig
-
-        sig { params(errors: T::Array[Error]).returns(T::Array[Error]) }
+        #: (Array[Error] errors) -> Array[Error]
         def sort_errors_by_code(errors)
           errors.sort_by { |e| [e.code, e.file, e.line, e.message] }
         end
       end
       # Parse errors from Sorbet output
       class Parser
-        extend T::Sig
-
         class ParseError < Spoom::Error; end
 
         HEADER = T.let(
@@ -32,23 +28,21 @@ module Spoom
         )
 
         class << self
-          extend T::Sig
-
-          sig { params(output: String, error_url_base: String).returns(T::Array[Error]) }
+          #: (String output, ?error_url_base: String) -> Array[Error]
           def 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
         end
 
-        sig { params(error_url_base: String).void }
+        #: (?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]) }
+        #: (String output) -> Array[Error]
         def parse(output)
           output.each_line do |line|
             break if /^No errors! Great job\./.match?(line)
@@ -71,7 +65,7 @@ module Spoom
 
         private
 
-        sig { params(error_url_base: String).returns(Regexp) }
+        #: (String error_url_base) -> Regexp
         def error_line_match_regexp(error_url_base)
           url = Regexp.escape(error_url_base)
           %r{
@@ -88,7 +82,7 @@ module Spoom
           }x
         end
 
-        sig { params(line: String).returns(T.nilable(Error)) }
+        #: (String line) -> Error?
         def match_error_line(line)
           match = line.match(@error_line_match_regex)
           return unless match
@@ -97,14 +91,14 @@ module Spoom
           Error.new(file, line&.to_i, message, code&.to_i)
         end
 
-        sig { params(error: Error).void }
+        #: (Error error) -> void
         def open_error(error)
           raise ParseError, "Error: Already parsing an error!" if @current_error
 
           @current_error = error
         end
 
-        sig { void }
+        #: -> void
         def close_error
           raise ParseError, "Error: Not already parsing an error!" unless @current_error
 
@@ -112,7 +106,7 @@ module Spoom
           @current_error = nil
         end
 
-        sig { params(line: String).void }
+        #: (String line) -> void
         def append_error(line)
           raise ParseError, "Error: Not already parsing an error!" unless @current_error
 
@@ -126,30 +120,21 @@ module Spoom
 
       class Error
         include Comparable
-        extend T::Sig
 
-        sig { returns(T.nilable(String)) }
+        #: String?
         attr_reader :file, :message
 
-        sig { returns(T.nilable(Integer)) }
+        #: Integer?
         attr_reader :line, :code
 
-        sig { returns(T::Array[String]) }
+        #: Array[String]
         attr_reader :more
 
         # Other files associated with the error
-        sig { returns(T::Set[String]) }
+        #: Set[String]
         attr_reader :files_from_error_sections
 
-        sig do
-          params(
-            file: T.nilable(String),
-            line: T.nilable(Integer),
-            message: T.nilable(String),
-            code: T.nilable(Integer),
-            more: T::Array[String],
-          ).void
-        end
+        #: (String? file, Integer? line, String? message, Integer? code, ?Array[String] more) -> void
         def initialize(file, line, message, code, more = [])
           @file = file
           @line = line
@@ -160,14 +145,14 @@ module Spoom
         end
 
         # By default errors are sorted by location
-        sig { params(other: T.untyped).returns(Integer) }
+        #: (untyped other) -> Integer
         def <=>(other)
           return 0 unless other.is_a?(Error)
 
           [file, line, code, message] <=> [other.file, other.line, other.code, other.message]
         end
 
-        sig { returns(String) }
+        #: -> String
         def to_s
           "#{file}:#{line}: #{message} (#{code})"
         end

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

@@ -10,14 +10,12 @@ module Spoom
     #
     # The language server protocol always uses `"2.0"` as the `jsonrpc` version.
     class Message
-      extend T::Sig
-
-      sig { void }
+      #: -> void
       def initialize
         @jsonrpc = T.let("2.0", String)
       end
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      #: -> Hash[untyped, untyped]
       def as_json
         instance_variables.each_with_object({}) do |var, obj|
           val = instance_variable_get(var)
@@ -25,7 +23,7 @@ module Spoom
         end
       end
 
-      sig { params(args: T.untyped).returns(String) }
+      #: (*untyped args) -> String
       def to_json(*args)
         T.unsafe(as_json).to_json(*args)
       end
@@ -35,15 +33,13 @@ module Spoom
     #
     # Every processed request must send a response back to the sender of the request.
     class Request < Message
-      extend T::Sig
-
-      sig { returns(Integer) }
+      #: Integer
       attr_reader :id
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      #: Hash[untyped, untyped]
       attr_reader :params
 
-      sig { params(id: Integer, method: String, params: T::Hash[T.untyped, T.untyped]).void }
+      #: (Integer id, String method, Hash[untyped, untyped] params) -> void
       def initialize(id, method, params)
         super()
         @id = id
@@ -56,15 +52,13 @@ module Spoom
     #
     # A processed notification message must not send a response back. They work like events.
     class Notification < Message
-      extend T::Sig
-
-      sig { returns(String) }
+      #: String
       attr_reader :method
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      #: Hash[untyped, untyped]
       attr_reader :params
 
-      sig { params(method: String, params: T::Hash[T.untyped, T.untyped]).void }
+      #: (String method, Hash[untyped, untyped] params) -> void
       def initialize(method, params)
         super()
         @method = method

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

@@ -8,18 +8,14 @@ module Spoom
       class BadHeaders < Error; end
 
       class Diagnostics < Error
-        extend T::Sig
-
-        sig { returns(String) }
+        #: String
         attr_reader :uri
 
-        sig { returns(T::Array[Diagnostic]) }
+        #: Array[Diagnostic]
         attr_reader :diagnostics
 
         class << self
-          extend T::Sig
-
-          sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostics) }
+          #: (Hash[untyped, untyped] json) -> Diagnostics
           def from_json(json)
             Diagnostics.new(
               json["uri"],
@@ -28,7 +24,7 @@ module Spoom
           end
         end
 
-        sig { params(uri: String, diagnostics: T::Array[Diagnostic]).void }
+        #: (String uri, Array[Diagnostic] diagnostics) -> void
         def initialize(uri, diagnostics)
           @uri = uri
           @diagnostics = diagnostics
@@ -38,18 +34,14 @@ module Spoom
     end
 
     class ResponseError < Error
-      extend T::Sig
-
-      sig { returns(Integer) }
+      #: Integer
       attr_reader :code
 
-      sig { returns(T::Hash[T.untyped, T.untyped]) }
+      #: Hash[untyped, untyped]
       attr_reader :data
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(ResponseError) }
+        #: (Hash[untyped, untyped] json) -> ResponseError
         def from_json(json)
           ResponseError.new(
             json["code"],
@@ -59,7 +51,7 @@ module Spoom
         end
       end
 
-      sig { params(code: Integer, message: String, data: T::Hash[T.untyped, T.untyped]).void }
+      #: (Integer code, String message, Hash[untyped, untyped] data) -> void
       def initialize(code, message, data)
         super(message)
         @code = code

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

@@ -17,16 +17,13 @@ module Spoom
     end
 
     class Hover < T::Struct
-      extend T::Sig
       include PrintableSymbol
 
       const :contents, String
       const :range, T.nilable(Range)
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Hover) }
+        #: (Hash[untyped, untyped] json) -> Hover
         def from_json(json)
           Hover.new(
             contents: json["contents"]["value"],
@@ -35,29 +32,27 @@ module Spoom
         end
       end
 
-      sig { override.params(printer: SymbolPrinter).void }
+      # @override
+      #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
         printer.print("#{contents}\n")
         printer.print_object(range) if range
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         "#{contents} (#{range})."
       end
     end
 
     class Position < T::Struct
-      extend T::Sig
       include PrintableSymbol
 
       const :line, Integer
       const :char, Integer
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Position) }
+        #: (Hash[untyped, untyped] json) -> Position
         def from_json(json)
           Position.new(
             line: json["line"].to_i,
@@ -66,28 +61,26 @@ module Spoom
         end
       end
 
-      sig { override.params(printer: SymbolPrinter).void }
+      # @override
+      #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
         printer.print_colored("#{line}:#{char}", Color::LIGHT_BLACK)
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         "#{line}:#{char}"
       end
     end
 
     class Range < T::Struct
-      extend T::Sig
       include PrintableSymbol
 
       const :start, Position
       const :end, Position
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Range) }
+        #: (Hash[untyped, untyped] json) -> Range
         def from_json(json)
           Range.new(
             start: Position.from_json(json["start"]),
@@ -96,30 +89,28 @@ module Spoom
         end
       end
 
-      sig { override.params(printer: SymbolPrinter).void }
+      # @override
+      #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
         printer.print_object(start)
         printer.print_colored("-", Color::LIGHT_BLACK)
         printer.print_object(self.end)
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         "#{start}-#{self.end}"
       end
     end
 
     class Location < T::Struct
-      extend T::Sig
       include PrintableSymbol
 
       const :uri, String
       const :range, LSP::Range
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Location) }
+        #: (Hash[untyped, untyped] json) -> Location
         def from_json(json)
           Location.new(
             uri: json["uri"],
@@ -128,20 +119,20 @@ module Spoom
         end
       end
 
-      sig { override.params(printer: SymbolPrinter).void }
+      # @override
+      #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
         printer.print_colored("#{printer.clean_uri(uri)}:", Color::LIGHT_BLACK)
         printer.print_object(range)
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         "#{uri}:#{range}"
       end
     end
 
     class SignatureHelp < T::Struct
-      extend T::Sig
       include PrintableSymbol
 
       const :label, T.nilable(String)
@@ -149,9 +140,7 @@ module Spoom
       const :params, T::Array[T.untyped] # TODO
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(SignatureHelp) }
+        #: (Hash[untyped, untyped] json) -> SignatureHelp
         def from_json(json)
           SignatureHelp.new(
             label: json["label"],
@@ -161,7 +150,8 @@ module Spoom
         end
       end
 
-      sig { override.params(printer: SymbolPrinter).void }
+      # @override
+      #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
         printer.print(label)
         printer.print("(")
@@ -169,14 +159,13 @@ module Spoom
         printer.print(")")
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         "#{label}(#{params})."
       end
     end
 
     class Diagnostic < T::Struct
-      extend T::Sig
       include PrintableSymbol
 
       const :range, LSP::Range
@@ -185,9 +174,7 @@ module Spoom
       const :information, Object
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostic) }
+        #: (Hash[untyped, untyped] json) -> Diagnostic
         def from_json(json)
           Diagnostic.new(
             range: Range.from_json(json["range"]),
@@ -198,19 +185,19 @@ module Spoom
         end
       end
 
-      sig { override.params(printer: SymbolPrinter).void }
+      # @override
+      #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
         printer.print(to_s)
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         "Error: #{message} (#{code})."
       end
     end
 
     class DocumentSymbol < T::Struct
-      extend T::Sig
       include PrintableSymbol
 
       const :name, String
@@ -221,9 +208,7 @@ module Spoom
       const :children, T::Array[DocumentSymbol]
 
       class << self
-        extend T::Sig
-
-        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(DocumentSymbol) }
+        #: (Hash[untyped, untyped] json) -> DocumentSymbol
         def from_json(json)
           DocumentSymbol.new(
             name: json["name"],
@@ -236,7 +221,8 @@ module Spoom
         end
       end
 
-      sig { override.params(printer: SymbolPrinter).void }
+      # @override
+      #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
         h = serialize.hash
         return if printer.seen.include?(h)
@@ -263,12 +249,12 @@ module Spoom
         # TODO: also display details?
       end
 
-      sig { returns(String) }
+      #: -> String
       def to_s
         "#{name} (#{range})"
       end
 
-      sig { returns(String) }
+      #: -> String
       def kind_string
         SYMBOL_KINDS[kind] || "<unknown:#{kind}>"
       end
@@ -307,22 +293,13 @@ module Spoom
     end
 
     class SymbolPrinter < Printer
-      extend T::Sig
-
-      sig { returns(T::Set[Integer]) }
+      #: Set[Integer]
       attr_reader :seen
 
-      sig { returns(T.nilable(String)) }
+      #: String?
       attr_accessor :prefix
 
-      sig do
-        params(
-          out: T.any(IO, StringIO),
-          colors: T::Boolean,
-          indent_level: Integer,
-          prefix: T.nilable(String),
-        ).void
-      end
+      #: (?out: (IO | StringIO), ?colors: bool, ?indent_level: Integer, ?prefix: String?) -> void
       def initialize(out: $stdout, colors: true, indent_level: 0, prefix: nil)
         super(out: out, colors: colors, indent_level: indent_level)
         @seen = T.let(Set.new, T::Set[Integer])
@@ -332,19 +309,19 @@ module Spoom
         @prefix = prefix
       end
 
-      sig { params(object: T.nilable(PrintableSymbol)).void }
+      #: (PrintableSymbol? object) -> void
       def print_object(object)
         return unless object
 
         object.accept_printer(self)
       end
 
-      sig { params(objects: T::Array[PrintableSymbol]).void }
+      #: (Array[PrintableSymbol] objects) -> void
       def print_objects(objects)
         objects.each { |object| print_object(object) }
       end
 
-      sig { params(uri: String).returns(String) }
+      #: (String uri) -> String
       def clean_uri(uri)
         prefix = self.prefix
         return uri unless prefix
@@ -352,7 +329,7 @@ module Spoom
         uri.delete_prefix(prefix)
       end
 
-      sig { params(objects: T::Array[PrintableSymbol]).void }
+      #: (Array[PrintableSymbol] objects) -> void
       def print_list(objects)
         objects.each do |object|
           printt