spoom 1.7.2 → 1.7.4

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

@@ -9,22 +9,75 @@ module Spoom
         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)
+        #: (Prism::StatementsNode) -> void
+        def visit_statements_node(node)
+          node.body.each do |statement|
+            translated = maybe_translate_assertion(statement)
+            visit(statement) unless translated
+          end
+        end
+
+        # @override
+        #: (Prism::IfNode) -> void
+        def visit_if_node(node)
+          if node.if_keyword_loc
+            # We do not translate assertions in ternary expressions to avoid altering the semantic of the code.
+            #
+            # For example:
+            # ```rb
+            # a = T.must(b) ? T.must(c) : T.must(d)
+            # ```
+            #
+            # would become
+            # ```rb
+            # a = T.must(b) ? T.must(c) : d #: !nil
+            # ```
+            #
+            # which does not match the original intent.
+            super
+          end
+        end
+
+        private
+
+        #: (Prism::Node) -> bool
+        def maybe_translate_assertion(node)
+          node = case node
+          when Prism::MultiWriteNode,
+               Prism::ClassVariableWriteNode, Prism::ClassVariableAndWriteNode, Prism::ClassVariableOperatorWriteNode, Prism::ClassVariableOrWriteNode,
+               Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantOrWriteNode,
+               Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOperatorWriteNode, Prism::ConstantPathOrWriteNode,
+               Prism::GlobalVariableWriteNode, Prism::GlobalVariableAndWriteNode, Prism::GlobalVariableOperatorWriteNode, Prism::GlobalVariableOrWriteNode,
+               Prism::InstanceVariableWriteNode, Prism::InstanceVariableAndWriteNode, Prism::InstanceVariableOperatorWriteNode, Prism::InstanceVariableOrWriteNode,
+               Prism::LocalVariableWriteNode, Prism::LocalVariableAndWriteNode, Prism::LocalVariableOperatorWriteNode, Prism::LocalVariableOrWriteNode,
+               Prism::CallAndWriteNode, Prism::CallOperatorWriteNode, Prism::CallOrWriteNode
+            node.value
+          when Prism::CallNode
+            node
+          else
+            return false
+          end
+
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless t_annotation?(node)
+          return false 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
+          @rewriter << if node.name == :bind
+            Source::Replace.new(start_offset, end_offset - 1, rbs_annotation)
+          else
+            Source::Replace.new(start_offset, end_offset - 1, "#{dedent_value(node, value)} #{rbs_annotation}")
+          end
+
+          true
+        end
 
-        #: (Prism::CallNode) -> void
+        #: (Prism::CallNode) -> String
         def build_rbs_annotation(call)
           case call.name
           when :let
@@ -35,6 +88,10 @@ module Spoom
             srb_type = call.arguments&.arguments&.last #: as !nil
             rbs_type = RBI::Type.parse_node(srb_type).rbs_string
             "#: as #{rbs_type}"
+          when :bind
+            srb_type = call.arguments&.arguments&.last #: as !nil
+            rbs_type = RBI::Type.parse_node(srb_type).rbs_string
+            "#: self as #{rbs_type}"
           when :must
             "#: as !nil"
           when :unsafe
@@ -65,6 +122,8 @@ module Spoom
           case node.name
           when :let, :cast
             return node.arguments&.arguments&.size == 2
+          when :bind
+            return node.arguments&.arguments&.size == 2 && node.arguments&.arguments&.first.is_a?(Prism::SelfNode)
           when :must, :unsafe
             return node.arguments&.arguments&.size == 1
           end

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

@@ -7,14 +7,18 @@ module Spoom
       # Converts all `sig` nodes to RBS comments in the given Ruby code.
       # It also handles type members and class annotations.
       class SorbetSigsToRBSComments < Translator
-        #: (String, file: String, positional_names: bool) -> void
-        def initialize(ruby_contents, file:, positional_names:)
+        #: (String, file: String, positional_names: bool, ?max_line_length: Integer?) -> void
+        def initialize(ruby_contents, file:, positional_names:, max_line_length: nil)
           super(ruby_contents, file: file)
 
           @positional_names = positional_names #: bool
-          @nesting = [] #: Array[Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode]
           @last_sigs = [] #: Array[[Prism::CallNode, RBI::Sig]]
+          @class_annotations = [] #: Array[Prism::CallNode]
           @type_members = [] #: Array[String]
+          @extend_t_helpers = [] #: Array[Prism::CallNode]
+          @extend_t_generics = [] #: Array[Prism::CallNode]
+          @seen_mixes_in_class_methods = false #: bool
+          @max_line_length = max_line_length #: Integer?
         end
 
         # @override
@@ -38,26 +42,23 @@ module Spoom
         # @override
         #: (Prism::DefNode) -> void
         def visit_def_node(node)
-          return if @last_sigs.empty?
-          return if @last_sigs.any? { |_, sig| sig.is_abstract }
+          last_sigs = collect_last_sigs
+          return if last_sigs.empty?
+          return if last_sigs.any? { |_, sig| sig.is_abstract }
 
-          apply_member_annotations(@last_sigs)
+          apply_member_annotations(last_sigs)
 
           # Build the RBI::Method node so we can print the method signature as RBS.
           builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
           builder.visit(node)
           rbi_node = builder.tree.nodes.first #: as RBI::Method
 
-          @last_sigs.each do |node, sig|
-            out = StringIO.new
-            p = RBI::RBSPrinter.new(out: out, indent: node.location.start_column, positional_names: @positional_names)
-            p.print("#: ")
-            p.send(:print_method_sig, rbi_node, sig)
-            p.print("\n")
-            @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out.string)
+          last_sigs.each do |node, sig|
+            out = rbs_print(node.location.start_column) do |printer|
+              printer.print_method_sig(rbi_node, sig)
+            end
+            @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out)
           end
-
-          @last_sigs.clear
         end
 
         # @override
@@ -71,7 +72,9 @@ module Spoom
           when "extend"
             visit_extend(node)
           when "abstract!", "interface!", "sealed!", "final!", "requires_ancestor"
-            visit_class_annotation(node)
+            @class_annotations << node
+          when "mixes_in_class_methods"
+            @seen_mixes_in_class_methods = true
           else
             super
           end
@@ -97,19 +100,39 @@ module Spoom
 
         #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) { -> void } -> void
         def visit_scope(node, &block)
-          @nesting << node
+          old_class_annotations = @class_annotations
+          @class_annotations = []
           old_type_members = @type_members
           @type_members = []
+          old_extend_t_helpers = @extend_t_helpers
+          @extend_t_helpers = []
+          old_extend_t_generics = @extend_t_generics
+          @extend_t_generics = []
+          old_seen_mixes_in_class_methods = @seen_mixes_in_class_methods
+          @seen_mixes_in_class_methods = false
 
           yield
 
+          delete_extend_t_generics
+
           if @type_members.any?
             indent = " " * node.location.start_column
             @rewriter << Source::Insert.new(node.location.start_offset, "#: [#{@type_members.join(", ")}]\n#{indent}")
           end
 
+          unless @seen_mixes_in_class_methods
+            delete_extend_t_helpers
+          end
+
+          @class_annotations.each do |call|
+            apply_class_annotation(node, call)
+          end
+
+          @class_annotations = old_class_annotations
           @type_members = old_type_members
-          @nesting.pop
+          @extend_t_helpers = old_extend_t_helpers
+          @extend_t_generics = old_extend_t_generics
+          @seen_mixes_in_class_methods = old_seen_mixes_in_class_methods
         end
 
         #: (Prism::CallNode) -> void
@@ -130,25 +153,22 @@ module Spoom
             raise Error, "Expected attr_reader, attr_writer, or attr_accessor"
           end
 
-          return if @last_sigs.empty?
-          return if @last_sigs.any? { |_, sig| sig.is_abstract }
+          last_sigs = collect_last_sigs
+          return if last_sigs.empty?
+          return if last_sigs.any? { |_, sig| sig.is_abstract }
 
-          apply_member_annotations(@last_sigs)
+          apply_member_annotations(last_sigs)
 
           builder = RBI::Parser::TreeBuilder.new(@ruby_contents, comments: [], file: @file)
           builder.visit(node)
           rbi_node = builder.tree.nodes.first #: as RBI::Attr
 
-          @last_sigs.each do |node, sig|
-            out = StringIO.new
-            p = RBI::RBSPrinter.new(out: out, indent: node.location.start_column, positional_names: @positional_names)
-            p.print("#: ")
-            p.print_attr_sig(rbi_node, sig)
-            p.print("\n")
-            @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out.string)
+          last_sigs.each do |node, sig|
+            out = rbs_print(node.location.start_column) do |printer|
+              printer.print_attr_sig(rbi_node, sig)
+            end
+            @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out)
           end
-
-          @last_sigs.clear
         end
 
         #: (Prism::CallNode node) -> void
@@ -160,16 +180,17 @@ module Spoom
 
           arg = node.arguments&.arguments&.first
           return unless arg.is_a?(Prism::ConstantPathNode)
-          return unless arg.slice.match?(/^(::)?T::Helpers$/) || arg.slice.match?(/^(::)?T::Generic$/)
 
-          from = adjust_to_line_start(node.location.start_offset)
-          to = adjust_to_line_end(node.location.end_offset)
-          to = adjust_to_new_line(to)
-          @rewriter << Source::Delete.new(from, to)
+          case arg.slice
+          when /^(::)?T::Helpers$/
+            @extend_t_helpers << node
+          when /^(::)?T::Generic$/
+            @extend_t_generics << node
+          end
         end
 
-        #: (Prism::CallNode node) -> void
-        def visit_class_annotation(node)
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode, Prism::CallNode) -> void
+        def apply_class_annotation(parent, node)
           unless node.message == "abstract!" || node.message == "interface!" || node.message == "sealed!" ||
               node.message == "final!" || node.message == "requires_ancestor"
             raise Error, "Expected abstract!, interface!, sealed!, final!, or requires_ancestor"
@@ -178,18 +199,17 @@ module Spoom
           return unless node.receiver.nil? || node.receiver.is_a?(Prism::SelfNode)
           return unless node.arguments.nil?
 
-          klass = @nesting.last #: as Prism::Node
-          indent = " " * klass.location.start_column
+          indent = " " * parent.location.start_column
 
           case node.message
           when "abstract!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @abstract\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @abstract\n#{indent}")
           when "interface!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @interface\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @interface\n#{indent}")
           when "sealed!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @sealed\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @sealed\n#{indent}")
           when "final!"
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @final\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @final\n#{indent}")
           when "requires_ancestor"
             block = node.block
             return unless block.is_a?(Prism::BlockNode)
@@ -200,7 +220,7 @@ module Spoom
 
             arg = body.body.first #: as Prism::Node
             srb_type = RBI::Type.parse_node(arg)
-            @rewriter << Source::Insert.new(klass.location.start_offset, "# @requires_ancestor: #{srb_type.rbs_string}\n#{indent}")
+            @rewriter << Source::Insert.new(parent.location.start_offset, "# @requires_ancestor: #{srb_type.rbs_string}\n#{indent}")
           end
 
           from = adjust_to_line_start(node.location.start_offset)
@@ -287,6 +307,54 @@ module Spoom
 
           type_member
         end
+
+        #: -> void
+        def delete_extend_t_helpers
+          @extend_t_helpers.each do |helper|
+            from = adjust_to_line_start(helper.location.start_offset)
+            to = adjust_to_line_end(helper.location.end_offset)
+            to = adjust_to_new_line(to)
+            @rewriter << Source::Delete.new(from, to)
+          end
+
+          @extend_t_helpers.clear
+        end
+
+        #: -> void
+        def delete_extend_t_generics
+          @extend_t_generics.each do |generic|
+            from = adjust_to_line_start(generic.location.start_offset)
+            to = adjust_to_line_end(generic.location.end_offset)
+            to = adjust_to_new_line(to)
+            @rewriter << Source::Delete.new(from, to)
+          end
+
+          @extend_t_generics.clear
+        end
+
+        # Collects the last signatures visited and clears the current list
+        #: -> Array[[Prism::CallNode, RBI::Sig]]
+        def collect_last_sigs
+          last_sigs = @last_sigs
+          @last_sigs = []
+          last_sigs
+        end
+
+        #: (Integer) { (RBI::RBSPrinter) -> void } -> String
+        def rbs_print(indent, &block)
+          out = StringIO.new
+          p = RBI::RBSPrinter.new(out: out, positional_names: @positional_names, max_line_length: @max_line_length)
+          block.call(p)
+          string = out.string
+
+          string.lines.map.with_index do |line, index|
+            if index == 0
+              "#: #{line}"
+            else
+              "#{" " * indent}#| #{line}"
+            end
+          end.join + "\n"
+        end
       end
     end
   end

data/lib/spoom/sorbet/translate.rb

@@ -25,16 +25,16 @@ module Spoom
 
         # Converts all `sig` nodes to RBS comments in the given Ruby code.
         # It also handles type members and class annotations.
-        #: (String ruby_contents, file: String, ?positional_names: bool) -> String
-        def sorbet_sigs_to_rbs_comments(ruby_contents, file:, positional_names: true)
-          SorbetSigsToRBSComments.new(ruby_contents, file: file, positional_names: positional_names).rewrite
+        #: (String ruby_contents, file: String, ?positional_names: bool, ?max_line_length: Integer?) -> String
+        def sorbet_sigs_to_rbs_comments(ruby_contents, file:, positional_names: true, max_line_length: nil)
+          SorbetSigsToRBSComments.new(ruby_contents, file: file, positional_names: positional_names, max_line_length: max_line_length).rewrite
         end
 
         # Converts all the RBS comments in the given Ruby code to `sig` nodes.
         # It also handles type members and class annotations.
-        #: (String ruby_contents, file: String) -> String
-        def rbs_comments_to_sorbet_sigs(ruby_contents, file:)
-          RBSCommentsToSorbetSigs.new(ruby_contents, file: file).rewrite
+        #: (String ruby_contents, file: String, ?max_line_length: Integer?) -> String
+        def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil)
+          RBSCommentsToSorbetSigs.new(ruby_contents, file: file, max_line_length: max_line_length).rewrite
         end
 
         # Converts all `T.let` and `T.cast` nodes to RBS comments in the given Ruby code.

data/lib/spoom/source/rewriter.rb

@@ -158,7 +158,10 @@ module Spoom
       def rewrite!(bytes)
         # To avoid remapping positions after each edit,
         # we sort the changes by position and apply them in reverse order.
-        @edits.sort_by(&:range).reverse_each do |edit|
+        # When ranges are equal, preserve the original order
+        @edits.each_with_index.sort_by do |(edit, idx)|
+          [edit.range, idx]
+        end.reverse_each do |(edit, _)|
           edit.apply(bytes)
         end
       end

data/lib/spoom/version.rb

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