spoom 1.5.4 → 1.6.1

data/lib/spoom/sorbet/lsp.rb

@@ -11,9 +11,7 @@ require_relative "lsp/errors"
 module Spoom
   module LSP
     class Client
-      extend T::Sig
-
-      sig { params(sorbet_bin: String, sorbet_args: String, path: String).void }
+      #: (String sorbet_bin, *String sorbet_args, ?path: String) -> void
       def initialize(sorbet_bin, *sorbet_args, path: ".")
         @id = T.let(0, Integer)
         @open = T.let(false, T::Boolean)
@@ -23,23 +21,23 @@ module Spoom
         @err = T.let(io_err, IO)
       end
 
-      sig { returns(Integer) }
+      #: -> Integer
       def next_id
         @id += 1
       end
 
-      sig { params(json_string: String).void }
+      #: (String json_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])) }
+      #: (Message message) -> Hash[untyped, untyped]?
       def send(message)
         send_raw(message.to_json)
         read if message.is_a?(Request)
       end
 
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def read_raw
         header = @out.gets
 
@@ -50,7 +48,7 @@ module Spoom
         @out.read(len + 2) # +2 'cause of the final \r\n
       end
 
-      sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+      #: -> Hash[untyped, untyped]?
       def read
         raw_string = read_raw
         return unless raw_string
@@ -68,7 +66,7 @@ module Spoom
 
       # LSP requests
 
-      sig { params(workspace_path: String).void }
+      #: (String workspace_path) -> void
       def open(workspace_path)
         raise Error::AlreadyOpen, "Error: CLI already opened" if @open
 
@@ -85,7 +83,7 @@ module Spoom
         @open = true
       end
 
-      sig { params(uri: String, line: Integer, column: Integer).returns(T.nilable(Hover)) }
+      #: (String uri, Integer line, Integer column) -> Hover?
       def hover(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -106,7 +104,7 @@ module Spoom
         Hover.from_json(json["result"])
       end
 
-      sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[SignatureHelp]) }
+      #: (String uri, Integer line, Integer column) -> Array[SignatureHelp]
       def signatures(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -127,7 +125,7 @@ module Spoom
         json["result"]["signatures"].map { |loc| SignatureHelp.from_json(loc) }
       end
 
-      sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[Location]) }
+      #: (String uri, Integer line, Integer column) -> Array[Location]
       def definitions(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -148,7 +146,7 @@ module Spoom
         json["result"].map { |loc| Location.from_json(loc) }
       end
 
-      sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[Location]) }
+      #: (String uri, Integer line, Integer column) -> Array[Location]
       def type_definitions(uri, line, column)
         json = send(Request.new(
           next_id,
@@ -169,7 +167,7 @@ module Spoom
         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]) }
+      #: (String uri, Integer line, Integer column, ?bool include_decl) -> Array[Location]
       def references(uri, line, column, include_decl = true)
         json = send(Request.new(
           next_id,
@@ -193,7 +191,7 @@ module Spoom
         json["result"].map { |loc| Location.from_json(loc) }
       end
 
-      sig { params(query: String).returns(T::Array[DocumentSymbol]) }
+      #: (String query) -> Array[DocumentSymbol]
       def symbols(query)
         json = send(Request.new(
           next_id,
@@ -208,7 +206,7 @@ module Spoom
         json["result"].map { |loc| DocumentSymbol.from_json(loc) }
       end
 
-      sig { params(uri: String).returns(T::Array[DocumentSymbol]) }
+      #: (String uri) -> Array[DocumentSymbol]
       def document_symbols(uri)
         json = send(Request.new(
           next_id,
@@ -225,7 +223,7 @@ module Spoom
         json["result"].map { |loc| DocumentSymbol.from_json(loc) }
       end
 
-      sig { void }
+      #: -> void
       def close
         send(Request.new(next_id, "shutdown", {}))
         @in.close

data/lib/spoom/sorbet/metrics.rb

@@ -9,19 +9,17 @@ module Spoom
       DEFAULT_PREFIX = "ruby_typer.unknown."
 
       class << self
-        extend T::Sig
-
-        sig { params(path: String, prefix: String).returns(T::Hash[String, Integer]) }
+        #: (String path, ?String prefix) -> 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]) }
+        #: (String string, ?String prefix) -> 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]) }
+        #: (Hash[String, untyped] obj, ?String prefix) -> Hash[String, Integer]
         def parse_hash(obj, prefix = DEFAULT_PREFIX)
           obj["metrics"].each_with_object(Hash.new(0)) do |metric, metrics|
             name = metric["name"]

data/lib/spoom/sorbet/sigils.rb

@@ -7,8 +7,6 @@
 module Spoom
   module Sorbet
     module Sigils
-      extend T::Sig
-
       STRICTNESS_IGNORE = "ignore"
       STRICTNESS_FALSE = "false"
       STRICTNESS_TRUE = "true"
@@ -31,35 +29,33 @@ module Spoom
       SIGIL_REGEXP = T.let(/^#[[:blank:]]*typed:[[:blank:]]*(\S*)/, Regexp)
 
       class << self
-        extend T::Sig
-
         # returns the full sigil comment string for the passed strictness
-        sig { params(strictness: String).returns(String) }
+        #: (String strictness) -> String
         def sigil_string(strictness)
           "# typed: #{strictness}"
         end
 
         # returns true if the passed string is a valid strictness (else false)
-        sig { params(strictness: String).returns(T::Boolean) }
+        #: (String strictness) -> bool
         def valid_strictness?(strictness)
           VALID_STRICTNESS.include?(strictness.strip)
         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)) }
+        #: (String content) -> String?
         def strictness_in_content(content)
           SIGIL_REGEXP.match(content)&.[](1)
         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) }
+        #: (String content, String new_strictness) -> String
         def update_sigil(content, new_strictness)
           content.sub(SIGIL_REGEXP, sigil_string(new_strictness))
         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)) }
+        #: ((String | Pathname) path) -> String?
         def file_strictness(path)
           return unless File.file?(path)
 
@@ -68,7 +64,7 @@ module Spoom
         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) }
+        #: ((String | Pathname) path, String new_strictness) -> bool
         def change_sigil_in_file(path, new_strictness)
           content = File.read(path, encoding: Encoding::ASCII_8BIT)
           new_content = update_sigil(content, new_strictness)
@@ -79,7 +75,7 @@ module Spoom
         end
 
         # 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]) }
+        #: (Array[String] path_list, String new_strictness) -> Array[String]
         def change_sigil_in_files(path_list, new_strictness)
           path_list.filter do |path|
             change_sigil_in_file(path, new_strictness)

data/lib/spoom/sorbet/sigs.rb

@@ -6,12 +6,11 @@ require "rbi"
 module Spoom
   module Sorbet
     class Sigs
+      class Error < Spoom::Error; end
       class << self
-        extend T::Sig
-
-        sig { params(ruby_contents: String).returns(String) }
+        #: (String ruby_contents) -> String
         def strip(ruby_contents)
-          sigs = collect_sigs(ruby_contents)
+          sigs = collect_sorbet_sigs(ruby_contents)
           lines_to_strip = sigs.flat_map { |sig, _| (sig.loc&.begin_line..sig.loc&.end_line).to_a }
 
           lines = []
@@ -21,10 +20,10 @@ module Spoom
           lines.join
         end
 
-        sig { params(ruby_contents: String).returns(String) }
-        def rbi_to_rbs(ruby_contents)
+        #: (String ruby_contents, positional_names: bool) -> String
+        def rbi_to_rbs(ruby_contents, positional_names: true)
           ruby_contents = ruby_contents.dup
-          sigs = collect_sigs(ruby_contents)
+          sigs = collect_sorbet_sigs(ruby_contents)
 
           sigs.each do |sig, node|
             scanner = Scanner.new(ruby_contents)
@@ -36,7 +35,32 @@ module Spoom
               sig.loc&.end_line&.pred,
               T.must(sig.loc).end_column,
             )
-            ruby_contents[start_index...end_index] = SigTranslator.translate(sig, node)
+            rbs = RBIToRBSTranslator.translate(sig, node, positional_names: positional_names)
+            ruby_contents[start_index...end_index] = rbs
+          end
+
+          ruby_contents
+        end
+
+        #: (String ruby_contents) -> String
+        def rbs_to_rbi(ruby_contents)
+          ruby_contents = ruby_contents.dup
+          rbs_comments = collect_rbs_comments(ruby_contents)
+
+          rbs_comments.each do |rbs_comment, node|
+            scanner = Scanner.new(ruby_contents)
+            start_index = scanner.find_char_position(
+              T.must(rbs_comment.loc&.begin_line&.pred),
+              T.must(rbs_comment.loc).begin_column,
+            )
+            end_index = scanner.find_char_position(
+              rbs_comment.loc&.end_line&.pred,
+              T.must(rbs_comment.loc).end_column,
+            )
+            rbi = RBSToRBITranslator.translate(rbs_comment, node)
+            next unless rbi
+
+            ruby_contents[start_index...end_index] = rbi
           end
 
           ruby_contents
@@ -44,28 +68,39 @@ module Spoom
 
         private
 
-        sig { params(ruby_contents: String).returns(T::Array[[RBI::Sig, T.any(RBI::Method, RBI::Attr)]]) }
-        def collect_sigs(ruby_contents)
+        #: (String ruby_contents) -> Array[[RBI::Sig, (RBI::Method | RBI::Attr)]]
+        def collect_sorbet_sigs(ruby_contents)
           tree = RBI::Parser.parse_string(ruby_contents)
           visitor = SigsLocator.new
           visitor.visit(tree)
-          visitor.sigs.sort_by { |sig, _rbs_string| -T.must(sig.loc&.begin_line) }
+          visitor.sigs.sort_by { |sig, _node| -T.must(sig.loc&.begin_line) }
+        end
+
+        #: (String ruby_contents) -> Array[[RBI::RBSComment, (RBI::Method | RBI::Attr)]]
+        def collect_rbs_comments(ruby_contents)
+          tree = RBI::Parser.parse_string(ruby_contents)
+          visitor = SigsLocator.new
+          visitor.visit(tree)
+          visitor.rbs_comments.sort_by { |comment, _node| -T.must(comment.loc&.begin_line) }
         end
       end
 
       class SigsLocator < RBI::Visitor
-        extend T::Sig
-
-        sig { returns(T::Array[[RBI::Sig, T.any(RBI::Method, RBI::Attr)]]) }
+        #: Array[[RBI::Sig, (RBI::Method | RBI::Attr)]]
         attr_reader :sigs
 
-        sig { void }
+        #: Array[[RBI::RBSComment, (RBI::Method | RBI::Attr)]]
+        attr_reader :rbs_comments
+
+        #: -> void
         def initialize
           super
           @sigs = T.let([], T::Array[[RBI::Sig, T.any(RBI::Method, RBI::Attr)]])
+          @rbs_comments = T.let([], T::Array[[RBI::RBSComment, T.any(RBI::Method, RBI::Attr)]])
         end
 
-        sig { override.params(node: T.nilable(RBI::Node)).void }
+        # @override
+        #: (RBI::Node? node) -> void
         def visit(node)
           return unless node
 
@@ -76,32 +111,33 @@ module Spoom
 
               @sigs << [sig, node]
             end
+            node.comments.grep(RBI::RBSComment).each do |rbs_comment|
+              @rbs_comments << [rbs_comment, node]
+            end
           when RBI::Tree
             visit_all(node.nodes)
           end
         end
       end
 
-      class SigTranslator
+      class RBIToRBSTranslator
         class << self
-          extend T::Sig
-
-          sig { params(sig: RBI::Sig, node: T.any(RBI::Method, RBI::Attr)).returns(String) }
-          def translate(sig, node)
+          #: (RBI::Sig sig, (RBI::Method | RBI::Attr) node, positional_names: bool) -> String
+          def translate(sig, node, positional_names: true)
             case node
             when RBI::Method
-              translate_method_sig(sig, node)
+              translate_method_sig(sig, node, positional_names: positional_names)
             when RBI::Attr
-              translate_attr_sig(sig, node)
+              translate_attr_sig(sig, node, positional_names: positional_names)
             end
           end
 
           private
 
-          sig { params(sig: RBI::Sig, node: RBI::Method).returns(String) }
-          def translate_method_sig(sig, node)
+          #: (RBI::Sig sig, RBI::Method node, positional_names: bool) -> String
+          def translate_method_sig(sig, node, positional_names: true)
             out = StringIO.new
-            p = RBI::RBSPrinter.new(out: out, indent: sig.loc&.begin_column)
+            p = RBI::RBSPrinter.new(out: out, indent: sig.loc&.begin_column, positional_names: positional_names)
 
             if node.sigs.any?(&:is_final)
               p.printn("# @final")
@@ -133,23 +169,86 @@ module Spoom
             out.string
           end
 
-          sig { params(sig: RBI::Sig, node: RBI::Attr).returns(String) }
-          def translate_attr_sig(sig, node)
+          #: (RBI::Sig sig, RBI::Attr node, positional_names: bool) -> String
+          def translate_attr_sig(sig, node, positional_names: true)
             out = StringIO.new
-            p = RBI::RBSPrinter.new(out: out)
+            p = RBI::RBSPrinter.new(out: out, positional_names: positional_names)
             p.print_attr_sig(node, sig)
             "#: #{out.string}"
           end
         end
       end
 
+      class RBSToRBITranslator
+        class << self
+          extend T::Sig
+
+          #: (RBI::RBSComment comment, (RBI::Method | RBI::Attr) node) -> String?
+          def translate(comment, node)
+            case node
+            when RBI::Method
+              translate_method_sig(comment, node)
+            when RBI::Attr
+              translate_attr_sig(comment, node)
+            end
+          rescue RBS::ParsingError
+            nil
+          end
+
+          private
+
+          #: (RBI::RBSComment rbs_comment, RBI::Method node) -> String
+          def translate_method_sig(rbs_comment, node)
+            method_type = ::RBS::Parser.parse_method_type(rbs_comment.text)
+            translator = RBI::RBS::MethodTypeTranslator.new(node)
+            translator.visit(method_type)
+
+            # TODO: move this to `rbi`
+            res = translator.result
+            node.comments.each do |comment|
+              case comment.text
+              when "@abstract"
+                res.is_abstract = true
+              when "@final"
+                res.is_final = true
+              when "@override"
+                res.is_override = true
+              when "@override(allow_incompatible: true)"
+                res.is_override = true
+                res.allow_incompatible_override = true
+              when "@overridable"
+                res.is_overridable = true
+              end
+            end
+
+            res.string.strip
+          end
+
+          #: (RBI::RBSComment comment, RBI::Attr node) -> String
+          def translate_attr_sig(comment, node)
+            attr_type = ::RBS::Parser.parse_type(comment.text)
+            sig = RBI::Sig.new
+
+            if node.is_a?(RBI::AttrWriter)
+              if node.names.size != 1
+                raise Error, "AttrWriter must have exactly one name"
+              end
+
+              name = T.must(node.names.first)
+              sig.params << RBI::SigParam.new(name.to_s, RBI::RBS::TypeTranslator.translate(attr_type))
+            end
+
+            sig.return_type = RBI::RBS::TypeTranslator.translate(attr_type)
+            sig.string.strip
+          end
+        end
+      end
+
       # From https://github.com/Shopify/ruby-lsp/blob/9154bfc6ef/lib/ruby_lsp/document.rb#L127
       class Scanner
-        extend T::Sig
-
         LINE_BREAK = T.let(0x0A, Integer)
 
-        sig { params(source: String).void }
+        #: (String source) -> void
         def initialize(source)
           @current_line = T.let(0, Integer)
           @pos = T.let(0, Integer)
@@ -157,7 +256,7 @@ module Spoom
         end
 
         # Finds the character index inside the source string for a given line and column
-        sig { params(line: Integer, character: Integer).returns(Integer) }
+        #: (Integer line, Integer character) -> Integer
         def find_char_position(line, character)
           # Find the character index for the beginning of the requested line
           until @current_line == line

data/lib/spoom/sorbet.rb

@@ -1,6 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "spoom/sorbet/assertions"
 require "spoom/sorbet/config"
 require "spoom/sorbet/errors"
 require "spoom/sorbet/lsp"
@@ -12,20 +13,13 @@ require "open3"
 module Spoom
   module Sorbet
     class Error < Spoom::Error
-      extend T::Sig
-
       class Killed < Error; end
       class Segfault < Error; end
 
-      sig { returns(ExecResult) }
+      #: ExecResult
       attr_reader :result
 
-      sig do
-        params(
-          message: String,
-          result: ExecResult,
-        ).void
-      end
+      #: (String message, ExecResult result) -> void
       def initialize(message, result)
         super(message)
 

data/lib/spoom/timeline.rb

@@ -3,9 +3,7 @@
 
 module Spoom
   class Timeline
-    extend T::Sig
-
-    sig { params(context: Context, from: Time, to: Time).void }
+    #: (Context context, Time from, Time to) -> void
     def initialize(context, from, to)
       @context = context
       @from = from
@@ -13,13 +11,13 @@ module Spoom
     end
 
     # Return one commit for each month between `from` and `to`
-    sig { returns(T::Array[Git::Commit]) }
+    #: -> Array[Git::Commit]
     def ticks
       commits_for_dates(months)
     end
 
     # Return all months between `from` and `to`
-    sig { returns(T::Array[Time]) }
+    #: -> Array[Time]
     def months
       d = Date.new(@from.year, @from.month, 1)
       to = Date.new(@to.year, @to.month, 1)
@@ -32,7 +30,7 @@ module Spoom
     end
 
     # Return one commit for each date in `dates`
-    sig { params(dates: T::Array[Time]).returns(T::Array[Git::Commit]) }
+    #: (Array[Time] dates) -> Array[Git::Commit]
     def commits_for_dates(dates)
       dates.map do |t|
         result = @context.git_log(

data/lib/spoom/version.rb

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