spoom 1.6.3 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e47e1d01da6e3ee465eccc91bb4e3cd29549bb06d585ec0c3b6c6c129120a56
-  data.tar.gz: fbff7dfda675c426510d4147ab5ebaa281eb3480eb5bf8c09648b143f46a9c40
+  metadata.gz: 232ecacb9d25232ca17356951f795baf011b5ec9dd4c18b5688be1c474bccf2b
+  data.tar.gz: 824782c6b5b810cae1a88805e3dd196a4499f4f04fce86e57fc933873958cbd9
 SHA512:
-  metadata.gz: 2e555b99d0fca2a6e4a2da4cc5b36313d8823d4736c205187f52bab79670e839251cd22f47ba525c171ca3cff6dc59559b95969f3c7fc6aa103ff7d38f1144fa
-  data.tar.gz: 8a2c8b5e18b55c1f5813e33f2ebe03c86610de90c96b6d805bded2f79278da2897862a97bf70de5843135086373435e22bffc71f10b9aaf71b67d118797731e7
+  metadata.gz: de1b4478214f3be4f3369b7930cd6a3b96dac3e6c5ba506a3e25380bf1733b093996851dc59537ef56c2700eb63e3d0c317cc3ab44d0690e0255da38c0e6da77
+  data.tar.gz: 61e14bcfd81428eb251b514b4b21c0febd5df783bc5221e68d1c5ca44e3c5ae34017c12e13d034d331c31ee8900a38847e3712197797431122c5a24d57fc144b

data/lib/spoom/cli/srb/assertions.rb

@@ -19,7 +19,7 @@ module Spoom
             "in `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
 
           transformed_files = transform_files(files) do |file, contents|
-            Spoom::Sorbet::Assertions.rbi_to_rbs(contents, file: file)
+            Spoom::Sorbet::Translate.sorbet_assertions_to_rbs_comments(contents, file: file)
           end
 
           say("Translated type assertions in `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")

data/lib/spoom/cli/srb/sigs.rb

@@ -1,8 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "spoom/sorbet/sigs"
-
 module Spoom
   module Cli
     module Srb
@@ -34,12 +32,12 @@ module Spoom
 
           case from
           when "rbi"
-            transformed_files = transform_files(files) do |_file, contents|
-              Spoom::Sorbet::Sigs.rbi_to_rbs(contents, positional_names: options[:positional_names])
+            transformed_files = transform_files(files) do |file, contents|
+              Spoom::Sorbet::Translate.sorbet_sigs_to_rbs_comments(contents, file: file, positional_names: options[:positional_names])
             end
           when "rbs"
-            transformed_files = transform_files(files) do |_file, contents|
-              Spoom::Sorbet::Sigs.rbs_to_rbi(contents)
+            transformed_files = transform_files(files) do |file, contents|
+              Spoom::Sorbet::Translate.rbs_comments_to_sorbet_sigs(contents, file: file)
             end
           end
 
@@ -52,8 +50,8 @@ module Spoom
 
           say("Stripping signatures from `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
 
-          transformed_files = transform_files(files) do |_file, contents|
-            Spoom::Sorbet::Sigs.strip(contents)
+          transformed_files = transform_files(files) do |file, contents|
+            Spoom::Sorbet::Translate.strip_sorbet_sigs(contents, file: file)
           end
 
           say("Stripped signatures from `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")
@@ -93,8 +91,8 @@ module Spoom
           # Then, we transform the copied files to translate all the RBS signatures into RBI signatures.
           say("Translating signatures from RBS to RBI...")
           files = collect_files([copy_context.absolute_path])
-          transform_files(files) do |_file, contents|
-            Spoom::Sorbet::Sigs.rbs_to_rbi(contents)
+          transform_files(files) do |file, contents|
+            Spoom::Sorbet::Translate.rbs_comments_to_sorbet_sigs(contents, file: file)
           end
 
           # We need to inject `extend T::Sig` to be sure all the classes can run the `sig{}` blocks.

data/lib/spoom/deadcode/index.rb

@@ -49,10 +49,10 @@ module Spoom
 
       #: (String rb, file: String, ?plugins: Array[Plugins::Base]) -> void
       def index_ruby(rb, file:, plugins: [])
-        node, comments = Spoom.parse_ruby_with_comments(rb, file: file)
+        node = Spoom.parse_ruby(rb, file: file, comments: true)
 
         # Index definitions
-        model_builder = Model::Builder.new(@model, file, comments: comments)
+        model_builder = Model::Builder.new(@model, file)
         model_builder.visit(node)
 
         # Index references

data/lib/spoom/deadcode/plugins/active_record.rb

@@ -41,6 +41,11 @@ module Spoom
           "before_validation",
         ].freeze #: Array[String]
 
+        CALLBACK_CONDITIONS = [
+          "if",
+          "unless",
+        ].freeze #: Array[String]
+
         CRUD_METHODS = [
           "assign_attributes",
           "create",
@@ -63,9 +68,23 @@ module Spoom
         #: (Send send) -> void
         def on_send(send)
           if send.recv.nil? && CALLBACKS.include?(send.name)
+            # Process direct symbol arguments
             send.each_arg(Prism::SymbolNode) do |arg|
               @index.reference_method(arg.unescaped, send.location)
             end
+
+            # Process hash arguments for conditions like if: :method_name
+            send.each_arg_assoc do |key, value|
+              key = key.slice.delete_suffix(":")
+
+              case key
+              when *CALLBACK_CONDITIONS
+                if value&.is_a?(Prism::SymbolNode)
+                  @index.reference_method(value.unescaped, send.location)
+                end
+              end
+            end
+
             return
           end
 

data/lib/spoom/model/builder.rb

@@ -5,15 +5,12 @@ module Spoom
   class Model
     # Populate a Model by visiting the nodes from a Ruby file
     class Builder < NamespaceVisitor
-      #: (Model model, String file, ?comments: Array[Prism::Comment]) -> void
-      def initialize(model, file, comments:)
+      #: (Model model, String file) -> void
+      def initialize(model, file)
         super()
 
         @model = model
         @file = file
-        @comments_by_line = comments.to_h do |c|
-          [c.location.start_line, c]
-        end #: Hash[Integer, Prism::Comment]
         @namespace_nesting = [] #: Array[Namespace]
         @visibility_stack = [Visibility::Public] #: Array[Visibility]
         @last_sigs = [] #: Array[Sig]
@@ -263,22 +260,20 @@ module Spoom
 
       #: (Prism::Node node) -> Array[Comment]
       def node_comments(node)
+        last_line = node.location.start_line
         comments = []
 
-        start_line = node.location.start_line
-        start_line -= 1 unless @comments_by_line.key?(start_line)
+        node.location.leading_comments.reverse_each do |comment|
+          if comment.location.start_line < last_line - 1
+            break
+          end
 
-        start_line.downto(1) do |line|
-          comment = @comments_by_line[line]
-          break unless comment
+          last_line = comment.location.start_line
 
-          spoom_comment = Comment.new(
+          comments.unshift(Comment.new(
             comment.slice.gsub(/^#\s?/, "").rstrip,
             Location.from_prism(@file, comment.location),
-          )
-
-          comments.unshift(spoom_comment)
-          @comments_by_line.delete(line)
+          ))
         end
 
         comments

data/lib/spoom/model/model.rb

@@ -84,7 +84,7 @@ module Spoom
       #: Array[Comment]
       attr_reader :comments
 
-      #: (Symbol symbol, owner: Namespace?, location: Location, ?comments: Array[Comment]) -> void
+      #: (Symbol symbol, owner: Namespace?, location: Location, comments: Array[Comment]) -> void
       def initialize(symbol, owner:, location:, comments:)
         @symbol = symbol
         @owner = owner

data/lib/spoom/parse.rb

@@ -7,8 +7,8 @@ module Spoom
   class ParseError < Error; end
 
   class << self
-    #: (String ruby, file: String) -> Prism::Node
-    def parse_ruby(ruby, file:)
+    #: (String ruby, file: String, ?comments: bool) -> Prism::Node
+    def parse_ruby(ruby, file:, comments: false)
       result = Prism.parse(ruby)
       unless result.success?
         message = +"Error while parsing #{file}:\n"
@@ -20,23 +20,9 @@ module Spoom
         raise ParseError, message
       end
 
-      result.value
-    end
-
-    #: (String ruby, file: String) -> [Prism::Node, Array[Prism::Comment]]
-    def parse_ruby_with_comments(ruby, file:)
-      result = Prism.parse(ruby)
-      unless result.success?
-        message = +"Error while parsing #{file}:\n"
-
-        result.errors.each do |e|
-          message << "- #{e.message} (at #{e.location.start_line}:#{e.location.start_column})\n"
-        end
+      result.attach_comments! if comments
 
-        raise ParseError, message
-      end
-
-      [result.value, result.comments]
+      result.value
     end
   end
 end

data/lib/spoom/rbs.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module RBS
+    class Comments
+      #: Array[Annotations]
+      attr_reader :annotations
+
+      #: Array[Signature]
+      attr_reader :signatures
+
+      #: -> void
+      def initialize
+        @annotations = [] #: Array[Annotations]
+        @signatures = [] #: Array[Signature]
+      end
+
+      #: -> bool
+      def empty?
+        @annotations.empty? && @signatures.empty?
+      end
+    end
+
+    class Comment
+      #: String
+      attr_reader :string
+
+      #: Prism::Location
+      attr_reader :location
+
+      #: (String, Prism::Location) -> void
+      def initialize(string, location)
+        @string = string
+        @location = location
+      end
+    end
+
+    class Annotations < Comment; end
+    class Signature < Comment; end
+
+    module ExtractRBSComments
+      #: (Prism::Node) -> Comments
+      def node_rbs_comments(node)
+        res = Comments.new
+
+        comments = node.location.leading_comments.reverse
+        return res if comments.empty?
+
+        continuation_comments = [] #: Array[Prism::Comment]
+
+        comments.each do |comment|
+          string = comment.slice
+
+          if string.start_with?("# @")
+            string = string.delete_prefix("#").strip
+            res.annotations << Annotations.new(string, comment.location)
+          elsif string.start_with?("#: ")
+            string = string.delete_prefix("#:").strip
+            location = comment.location
+
+            continuation_comments.reverse_each do |continuation_comment|
+              string = "#{string}#{continuation_comment.slice.delete_prefix("#|")}"
+              location = location.join(continuation_comment.location)
+            end
+            continuation_comments.clear
+            res.signatures << Signature.new(string, location)
+          elsif string.start_with?("#|")
+            continuation_comments << comment
+          end
+        end
+
+        res
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb

@@ -0,0 +1,239 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      class RBSCommentsToSorbetSigs < Translator
+        include Spoom::RBS::ExtractRBSComments
+
+        # @override
+        #: (Prism::ClassNode node) -> void
+        def visit_class_node(node)
+          apply_class_annotations(node)
+
+          super
+        end
+
+        # @override
+        #: (Prism::ModuleNode node) -> void
+        def visit_module_node(node)
+          apply_class_annotations(node)
+
+          super
+        end
+
+        # @override
+        #: (Prism::SingletonClassNode node) -> void
+        def visit_singleton_class_node(node)
+          apply_class_annotations(node)
+
+          super
+        end
+
+        # @override
+        #: (Prism::DefNode node) -> void
+        def visit_def_node(node)
+          comments = node_rbs_comments(node)
+          return if comments.empty?
+
+          return if comments.signatures.empty?
+
+          builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
+          builder.visit(node)
+          rbi_node = builder.tree.nodes.first #: as RBI::Method
+
+          comments.signatures.each do |signature|
+            method_type = ::RBS::Parser.parse_method_type(signature.string)
+            translator = RBI::RBS::MethodTypeTranslator.new(rbi_node)
+            translator.visit(method_type)
+            sig = translator.result
+            apply_member_annotations(comments.annotations, sig)
+
+            @rewriter << Source::Replace.new(
+              signature.location.start_offset,
+              signature.location.end_offset,
+              sig.string,
+            )
+          rescue ::RBS::ParsingError
+            # Ignore signatures with errors
+            next
+          end
+        end
+
+        # @override
+        #: (Prism::CallNode node) -> void
+        def visit_call_node(node)
+          case node.message
+          when "attr_reader", "attr_writer", "attr_accessor"
+            visit_attr(node)
+          else
+            super
+          end
+        end
+
+        private
+
+        #: (Prism::CallNode) -> void
+        def visit_attr(node)
+          comments = node_rbs_comments(node)
+          return if comments.empty?
+
+          return if comments.signatures.empty?
+
+          comments.signatures.each do |signature|
+            attr_type = ::RBS::Parser.parse_type(signature.string)
+            sig = RBI::Sig.new
+
+            if node.message == "attr_writer"
+              if node.arguments&.arguments&.size != 1
+                raise Error, "AttrWriter must have exactly one name"
+              end
+
+              name = node.arguments&.arguments&.first #: as Prism::SymbolNode
+              sig.params << RBI::SigParam.new(
+                name.slice[1..-1], #: as String
+                RBI::RBS::TypeTranslator.translate(attr_type),
+              )
+            end
+
+            sig.return_type = RBI::RBS::TypeTranslator.translate(attr_type)
+
+            apply_member_annotations(comments.annotations, sig)
+
+            @rewriter << Source::Replace.new(
+              signature.location.start_offset,
+              signature.location.end_offset,
+              sig.string,
+            )
+          end
+        end
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) -> void
+        def apply_class_annotations(node)
+          comments = node_rbs_comments(node)
+          return if comments.empty?
+
+          indent = " " * (node.location.start_column + 2)
+          insert_pos = case node
+          when Prism::ClassNode
+            (node.superclass || node.constant_path).location.end_offset
+          when Prism::ModuleNode
+            node.constant_path.location.end_offset
+          when Prism::SingletonClassNode
+            node.expression.location.end_offset
+          end
+
+          if comments.annotations.any?
+            unless already_extends?(node, /^(::)?T::Helpers$/)
+              @rewriter << Source::Insert.new(insert_pos, "\n#{indent}extend T::Helpers\n")
+            end
+
+            comments.annotations.reverse_each do |annotation|
+              from = adjust_to_line_start(annotation.location.start_offset)
+              to = adjust_to_line_end(annotation.location.end_offset)
+              @rewriter << Source::Delete.new(from, to)
+
+              content = case annotation.string
+              when "@abstract"
+                "abstract!"
+              when "@interface"
+                "interface!"
+              when "@sealed"
+                "sealed!"
+              when "@final"
+                "final!"
+              when /^@requires_ancestor: /
+                srb_type = ::RBS::Parser.parse_type(annotation.string.delete_prefix("@requires_ancestor: "))
+                rbs_type = RBI::RBS::TypeTranslator.translate(srb_type)
+                "requires_ancestor { #{rbs_type} }"
+              end
+
+              newline = node.body.nil? ? "" : "\n"
+              @rewriter << Source::Insert.new(insert_pos, "\n#{indent}#{content}#{newline}")
+            end
+          end
+
+          signatures = comments.signatures
+          if signatures.any?
+            signatures.each do |signature|
+              type_params = ::RBS::Parser.parse_type_params(signature.string)
+              next if type_params.empty?
+
+              from = adjust_to_line_start(signature.location.start_offset)
+              to = adjust_to_line_end(signature.location.end_offset)
+              @rewriter << Source::Delete.new(from, to)
+
+              unless already_extends?(node, /^(::)?T::Generic$/)
+                @rewriter << Source::Insert.new(insert_pos, "\n#{indent}extend T::Generic\n")
+              end
+
+              type_params.each do |type_param|
+                type_member = "#{type_param.name} = type_member"
+
+                case type_param.variance
+                when :covariant
+                  type_member = "#{type_member}(:out)"
+                when :contravariant
+                  type_member = "#{type_member}(:in)"
+                end
+
+                if type_param.upper_bound || type_param.default_type
+                  if type_param.upper_bound
+                    rbs_type = RBI::RBS::TypeTranslator.translate(type_param.upper_bound)
+                    type_member = "#{type_member} {{ upper: #{rbs_type} }}"
+                  end
+
+                  if type_param.default_type
+                    rbs_type = RBI::RBS::TypeTranslator.translate(type_param.default_type)
+                    type_member = "#{type_member} {{ fixed: #{rbs_type} }}"
+                  end
+                end
+
+                newline = node.body.nil? ? "" : "\n"
+                @rewriter << Source::Insert.new(insert_pos, "\n#{indent}#{type_member}#{newline}")
+              end
+            end
+          end
+        end
+
+        #: (Array[RBS::Annotations], RBI::Sig) -> void
+        def apply_member_annotations(annotations, sig)
+          annotations.each do |annotation|
+            case annotation.string
+            when "@abstract"
+              sig.is_abstract = true
+            when "@final"
+              sig.is_final = true
+            when "@override"
+              sig.is_override = true
+            when "@override(allow_incompatible: true)"
+              sig.is_override = true
+              sig.allow_incompatible_override = true
+            when "@overridable"
+              sig.is_overridable = true
+            when "@without_runtime"
+              sig.without_runtime = true
+            end
+          end
+        end
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode, Regexp) -> bool
+        def already_extends?(node, constant_regex)
+          node.child_nodes.any? do |c|
+            next false unless c.is_a?(Prism::CallNode)
+            next false unless c.message == "extend"
+            next false unless c.receiver.nil? || c.receiver.is_a?(Prism::SelfNode)
+            next false unless c.arguments&.arguments&.size == 1
+
+            arg = c.arguments&.arguments&.first
+            next false unless arg.is_a?(Prism::ConstantPathNode)
+            next false unless arg.slice.match?(constant_regex)
+
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/translate/sorbet_assertions_to_rbs_comments.rb

@@ -0,0 +1,123 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Translate
+      # Translates Sorbet assertions to RBS comments.
+      class SorbetAssertionsToRBSComments < Translator
+        LINE_BREAK = "\n".ord #: Integer
+
+        # @override
+        #: (Prism::CallNode) -> void
+        def visit_call_node(node)
+          return super unless t_annotation?(node)
+          return super unless at_end_of_line?(node)
+
+          value = T.must(node.arguments&.arguments&.first)
+          rbs_annotation = build_rbs_annotation(node)
+
+          start_offset = node.location.start_offset
+          end_offset = node.location.end_offset
+          @rewriter << Source::Replace.new(start_offset, end_offset - 1, "#{dedent_value(node, value)} #{rbs_annotation}")
+        end
+
+        private
+
+        #: (Prism::CallNode) -> void
+        def build_rbs_annotation(call)
+          case call.name
+          when :let
+            srb_type = call.arguments&.arguments&.last #: as !nil
+            rbs_type = RBI::Type.parse_node(srb_type).rbs_string
+            "#: #{rbs_type}"
+          when :cast
+            srb_type = call.arguments&.arguments&.last #: as !nil
+            rbs_type = RBI::Type.parse_node(srb_type).rbs_string
+            "#: as #{rbs_type}"
+          when :must
+            "#: as !nil"
+          when :unsafe
+            "#: as untyped"
+          else
+            raise "Unknown annotation method: #{call.name}"
+          end
+        end
+
+        # Is this node a `T` or `::T` constant?
+        #: (Prism::Node?) -> bool
+        def t?(node)
+          case node
+          when Prism::ConstantReadNode
+            node.name == :T
+          when Prism::ConstantPathNode
+            node.parent.nil? && node.name == :T
+          else
+            false
+          end
+        end
+
+        # Is this node a `T.let` or `T.cast`?
+        #: (Prism::CallNode) -> bool
+        def t_annotation?(node)
+          return false unless t?(node.receiver)
+
+          case node.name
+          when :let, :cast
+            return node.arguments&.arguments&.size == 2
+          when :must, :unsafe
+            return node.arguments&.arguments&.size == 1
+          end
+
+          false
+        end
+
+        #: (Prism::Node) -> bool
+        def at_end_of_line?(node)
+          end_offset = node.location.end_offset
+          end_offset += 1 while (@ruby_bytes[end_offset] == " ".ord) && (end_offset < @ruby_bytes.size)
+          @ruby_bytes[end_offset] == LINE_BREAK
+        end
+
+        #: (Prism::Node, Prism::Node) -> String
+        def dedent_value(assign, value)
+          if value.location.start_line == assign.location.start_line
+            # The value is on the same line as the assign, so we can just return the slice as is:
+            # ```rb
+            # a = T.let(nil, T.nilable(String))
+            # ```
+            # becomes
+            # ```rb
+            # a = nil #: String?
+            # ```
+            return value.slice
+          end
+
+          # The value is on a different line, so we need to dedent it:
+          # ```rb
+          # a = T.let(
+          #   [
+          #     1, 2, 3,
+          #   ],
+          #   T::Array[Integer],
+          # )
+          # ```
+          # becomes
+          # ```rb
+          # a = [
+          #   1, 2, 3,
+          # ] #: Array[Integer]
+          # ```
+          indent = value.location.start_line - assign.location.start_line
+          lines = value.slice.lines
+          if lines.size > 1
+            lines[1..]&.each_with_index do |line, i|
+              lines[i + 1] = line.delete_prefix("  " * indent)
+            end
+          end
+          lines.join
+        end
+      end
+    end
+  end
+end