spoom 1.1.11 → 1.1.12

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

@@ -23,12 +23,16 @@ 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'],
-          range: json['range'] ? Range.from_json(json['range']) : nil
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Hover) }
+        def from_json(json)
+          Hover.new(
+            contents: json["contents"]["value"],
+            range: json["range"] ? Range.from_json(json["range"]) : nil
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -50,12 +54,16 @@ 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,
-          char: json['character'].to_i
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Position) }
+        def from_json(json)
+          Position.new(
+            line: json["line"].to_i,
+            char: json["character"].to_i
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -76,12 +84,16 @@ 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']),
-          end: Position.from_json(json['end'])
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Range) }
+        def from_json(json)
+          Range.new(
+            start: Position.from_json(json["start"]),
+            end: Position.from_json(json["end"])
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -104,12 +116,16 @@ 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'],
-          range: Range.from_json(json['range'])
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Location) }
+        def from_json(json)
+          Location.new(
+            uri: json["uri"],
+            range: Range.from_json(json["range"])
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -132,20 +148,24 @@ 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'],
-          doc: json['documentation'],
-          params: json['parameters'],
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(SignatureHelp) }
+        def from_json(json)
+          SignatureHelp.new(
+            label: json["label"],
+            doc: json["documentation"],
+            params: json["parameters"],
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         printer.print(label)
         printer.print("(")
-        printer.print(params.map { |l| "#{l['label']}: #{l['documentation']}" }.join(", "))
+        printer.print(params.map { |l| "#{l["label"]}: #{l["documentation"]}" }.join(", "))
         printer.print(")")
       end
 
@@ -164,14 +184,18 @@ 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']),
-          code: json['code'].to_i,
-          message: json['message'],
-          informations: json['relatedInformation']
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(Diagnostic) }
+        def from_json(json)
+          Diagnostic.new(
+            range: Range.from_json(json["range"]),
+            code: json["code"].to_i,
+            message: json["message"],
+            informations: json["relatedInformation"]
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
@@ -196,35 +220,40 @@ 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'],
-          detail: json['detail'],
-          kind: json['kind'],
-          location: json['location'] ? Location.from_json(json['location']) : nil,
-          range: json['range'] ? Range.from_json(json['range']) : nil,
-          children: json['children'] ? json['children'].map { |symbol| DocumentSymbol.from_json(symbol) } : [],
-        )
+      class << self
+        extend T::Sig
+
+        sig { params(json: T::Hash[T.untyped, T.untyped]).returns(DocumentSymbol) }
+        def from_json(json)
+          DocumentSymbol.new(
+            name: json["name"],
+            detail: json["detail"],
+            kind: json["kind"],
+            location: json["location"] ? Location.from_json(json["location"]) : nil,
+            range: json["range"] ? Range.from_json(json["range"]) : nil,
+            children: json["children"] ? json["children"].map { |symbol| DocumentSymbol.from_json(symbol) } : [],
+          )
+        end
       end
 
       sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         h = serialize.hash
         return if printer.seen.include?(h)
+
         printer.seen.add(h)
 
         printer.printt
         printer.print(kind_string)
-        printer.print(' ')
+        printer.print(" ")
         printer.print_colored(name, Color::BLUE, Color::BOLD)
-        printer.print_colored(' (', Color::LIGHT_BLACK)
+        printer.print_colored(" (", Color::LIGHT_BLACK)
         if range
           printer.print_object(range)
         elsif location
           printer.print_object(location)
         end
-        printer.print_colored(')', Color::LIGHT_BLACK)
+        printer.print_colored(")", Color::LIGHT_BLACK)
         printer.printn
         unless children.empty?
           printer.indent
@@ -303,6 +332,7 @@ module Spoom
       sig { params(object: T.nilable(PrintableSymbol)).void }
       def print_object(object)
         return unless object
+
         object.accept_printer(self)
       end
 
@@ -315,6 +345,7 @@ module Spoom
       def clean_uri(uri)
         prefix = self.prefix
         return uri unless prefix
+
         uri.delete_prefix(prefix)
       end
 
@@ -322,7 +353,7 @@ module Spoom
       def print_list(objects)
         objects.each do |object|
           printt
-          print "* "
+          print("* ")
           print_object(object)
           printn
         end

data/lib/spoom/sorbet/lsp.rb

@@ -1,12 +1,12 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'open3'
-require 'json'
+require "open3"
+require "json"
 
-require_relative 'lsp/base'
-require_relative 'lsp/structures'
-require_relative 'lsp/errors'
+require_relative "lsp/base"
+require_relative "lsp/structures"
+require_relative "lsp/errors"
 
 module Spoom
   module LSP
@@ -58,10 +58,10 @@ module Spoom
         json = JSON.parse(raw_string)
 
         # Handle error in the LSP protocol
-        raise ResponseError.from_json(json['error']) if json['error']
+        raise ResponseError.from_json(json["error"]) if json["error"]
 
         # Handle typechecking errors
-        raise Error::Diagnostics.from_json(json['params']) if json['method'] == "textDocument/publishDiagnostics"
+        raise Error::Diagnostics.from_json(json["params"]) if json["method"] == "textDocument/publishDiagnostics"
 
         json
       end
@@ -71,16 +71,17 @@ module Spoom
       sig { params(workspace_path: String).void }
       def open(workspace_path)
         raise Error::AlreadyOpen, "Error: CLI already opened" if @open
+
         send(Request.new(
           next_id,
-          'initialize',
+          "initialize",
           {
-            'rootPath' => workspace_path,
-            'rootUri' => "file://#{workspace_path}",
-            'capabilities' => {},
+            "rootPath" => workspace_path,
+            "rootUri" => "file://#{workspace_path}",
+            "capabilities" => {},
           },
         ))
-        send(Notification.new('initialized', {}))
+        send(Notification.new("initialized", {}))
         @open = true
       end
 
@@ -88,133 +89,140 @@ module Spoom
       def hover(uri, line, column)
         json = send(Request.new(
           next_id,
-          'textDocument/hover',
+          "textDocument/hover",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
           }
         ))
 
-        return nil unless json && json['result']
-        Hover.from_json(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,
-          'textDocument/signatureHelp',
+          "textDocument/signatureHelp",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
           }
         ))
 
-        return [] unless json && json['result'] && json['result']['signatures']
-        json['result']['signatures'].map { |loc| SignatureHelp.from_json(loc) }
+        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,
-          'textDocument/definition',
+          "textDocument/definition",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
           }
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| Location.from_json(loc) }
+        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,
-          'textDocument/typeDefinition',
+          "textDocument/typeDefinition",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
           }
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| Location.from_json(loc) }
+        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,
-          'textDocument/references',
+          "textDocument/references",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
-            'context' => {
-              'includeDeclaration' => include_decl,
+            "context" => {
+              "includeDeclaration" => include_decl,
             },
           }
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| Location.from_json(loc) }
+        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,
-          'workspace/symbol',
+          "workspace/symbol",
           {
-            'query' => query,
+            "query" => query,
           }
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+        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,
-          'textDocument/documentSymbol',
+          "textDocument/documentSymbol",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
           }
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+        return [] unless json && json["result"]
+
+        json["result"].map { |loc| DocumentSymbol.from_json(loc) }
       end
 
       sig { void }

data/lib/spoom/sorbet/metrics.rb

@@ -6,26 +6,28 @@ require_relative "sigils"
 module Spoom
   module Sorbet
     module MetricsParser
-      extend T::Sig
-
       DEFAULT_PREFIX = "ruby_typer.unknown.."
 
-      sig { params(path: String, prefix: String).returns(T::Hash[String, Integer]) }
-      def self.parse_file(path, prefix = DEFAULT_PREFIX)
-        parse_string(File.read(path), prefix)
-      end
+      class << self
+        extend T::Sig
 
-      sig { params(string: String, prefix: String).returns(T::Hash[String, Integer]) }
-      def self.parse_string(string, prefix = DEFAULT_PREFIX)
-        parse_hash(JSON.parse(string), prefix)
-      end
+        sig { params(path: String, prefix: String).returns(T::Hash[String, Integer]) }
+        def parse_file(path, prefix = DEFAULT_PREFIX)
+          parse_string(File.read(path), prefix)
+        end
+
+        sig { params(string: String, prefix: String).returns(T::Hash[String, Integer]) }
+        def parse_string(string, prefix = DEFAULT_PREFIX)
+          parse_hash(JSON.parse(string), prefix)
+        end
 
-      sig { params(obj: T::Hash[String, T.untyped], prefix: String).returns(T::Hash[String, Integer]) }
-      def self.parse_hash(obj, prefix = DEFAULT_PREFIX)
-        obj["metrics"].each_with_object(Hash.new(0)) do |metric, metrics|
-          name = metric["name"]
-          name = name.sub(prefix, '')
-          metrics[name] = metric["value"] || 0
+        sig { params(obj: T::Hash[String, T.untyped], prefix: String).returns(T::Hash[String, Integer]) }
+        def parse_hash(obj, prefix = DEFAULT_PREFIX)
+          obj["metrics"].each_with_object(Hash.new(0)) do |metric, metrics|
+            name = metric["name"]
+            name = name.sub(prefix, "")
+            metrics[name] = metric["value"] || 0
+          end
         end
       end
     end

data/lib/spoom/sorbet/sigils.rb

@@ -27,70 +27,75 @@ module Spoom
 
       SIGIL_REGEXP = T.let(/^#[\ t]*typed[\ t]*:[ \t]*(\w*)[ \t]*/.freeze, Regexp)
 
-      # returns the full sigil comment string for the passed strictness
-      sig { params(strictness: String).returns(String) }
-      def self.sigil_string(strictness)
-        "# typed: #{strictness}"
-      end
+      class << self
+        extend T::Sig
 
-      # returns true if the passed string is a valid strictness (else false)
-      sig { params(strictness: String).returns(T::Boolean) }
-      def self.valid_strictness?(strictness)
-        VALID_STRICTNESS.include?(strictness.strip)
-      end
+        # returns the full sigil comment string for the passed strictness
+        sig { params(strictness: String).returns(String) }
+        def sigil_string(strictness)
+          "# typed: #{strictness}"
+        end
 
-      # returns the strictness of a sigil in the passed file content string (nil if no sigil)
-      sig { params(content: String).returns(T.nilable(String)) }
-      def self.strictness_in_content(content)
-        SIGIL_REGEXP.match(content)&.[](1)
-      end
+        # returns true if the passed string is a valid strictness (else false)
+        sig { params(strictness: String).returns(T::Boolean) }
+        def valid_strictness?(strictness)
+          VALID_STRICTNESS.include?(strictness.strip)
+        end
 
-      # returns a string which is the passed content but with the sigil updated to a new strictness
-      sig { params(content: String, new_strictness: String).returns(String) }
-      def self.update_sigil(content, new_strictness)
-        content.sub(SIGIL_REGEXP, sigil_string(new_strictness))
-      end
+        # returns the strictness of a sigil in the passed file content string (nil if no sigil)
+        sig { params(content: String).returns(T.nilable(String)) }
+        def strictness_in_content(content)
+          SIGIL_REGEXP.match(content)&.[](1)
+        end
 
-      # returns a string containing the strictness of a sigil in a file at the passed path
-      # * returns nil if no sigil
-      sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
-      def self.file_strictness(path)
-        return nil unless File.file?(path)
-        content = File.read(path, encoding: Encoding::ASCII_8BIT)
-        strictness_in_content(content)
-      end
+        # returns a string which is the passed content but with the sigil updated to a new strictness
+        sig { params(content: String, new_strictness: String).returns(String) }
+        def update_sigil(content, new_strictness)
+          content.sub(SIGIL_REGEXP, sigil_string(new_strictness))
+        end
 
-      # changes the sigil in the file at the passed path to the specified new strictness
-      sig { params(path: T.any(String, Pathname), new_strictness: String).returns(T::Boolean) }
-      def self.change_sigil_in_file(path, new_strictness)
-        content = File.read(path, encoding: Encoding::ASCII_8BIT)
-        new_content = update_sigil(content, new_strictness)
+        # returns a string containing the strictness of a sigil in a file at the passed path
+        # * returns nil if no sigil
+        sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+        def file_strictness(path)
+          return nil unless File.file?(path)
 
-        File.write(path, new_content, encoding: Encoding::ASCII_8BIT)
+          content = File.read(path, encoding: Encoding::ASCII_8BIT)
+          strictness_in_content(content)
+        end
 
-        strictness_in_content(new_content) == new_strictness
-      end
+        # changes the sigil in the file at the passed path to the specified new strictness
+        sig { params(path: T.any(String, Pathname), new_strictness: String).returns(T::Boolean) }
+        def change_sigil_in_file(path, new_strictness)
+          content = File.read(path, encoding: Encoding::ASCII_8BIT)
+          new_content = update_sigil(content, new_strictness)
 
-      # changes the sigil to have a new strictness in a list of files
-      sig { params(path_list: T::Array[String], new_strictness: String).returns(T::Array[String]) }
-      def self.change_sigil_in_files(path_list, new_strictness)
-        path_list.filter do |path|
-          change_sigil_in_file(path, new_strictness)
+          File.write(path, new_content, encoding: Encoding::ASCII_8BIT)
+
+          strictness_in_content(new_content) == new_strictness
         end
-      end
 
-      # finds all files in the specified directory with the passed strictness
-      sig do
-        params(
-          directory: T.any(String, Pathname),
-          strictness: String,
-          extension: String
-        ).returns(T::Array[String])
-      end
-      def self.files_with_sigil_strictness(directory, strictness, extension: ".rb")
-        paths = Dir.glob("#{File.expand_path(directory)}/**/*#{extension}").sort.uniq
-        paths.filter do |path|
-          file_strictness(path) == strictness
+        # changes the sigil to have a new strictness in a list of files
+        sig { params(path_list: T::Array[String], new_strictness: String).returns(T::Array[String]) }
+        def change_sigil_in_files(path_list, new_strictness)
+          path_list.filter do |path|
+            change_sigil_in_file(path, new_strictness)
+          end
+        end
+
+        # finds all files in the specified directory with the passed strictness
+        sig do
+          params(
+            directory: T.any(String, Pathname),
+            strictness: String,
+            extension: String
+          ).returns(T::Array[String])
+        end
+        def files_with_sigil_strictness(directory, strictness, extension: ".rb")
+          paths = Dir.glob("#{File.expand_path(directory)}/**/*#{extension}").sort.uniq
+          paths.filter do |path|
+            file_strictness(path) == strictness
+          end
         end
       end
     end