spoom 1.8.1 → 1.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0cbd6c18447795a6c80c58456353edf11b7a591fb745a16b69b85076dbdb283b
-  data.tar.gz: ffb8f40253e1496b180aa6cee5d4d120567f95698b7e61f2e2992a3cfd978da8
+  metadata.gz: 9bf4851363229baee651a7eba14d9f45464db177f094f3b4da791a8b06b82d39
+  data.tar.gz: 6aae091a64fb4cb9a55cea3b82307bd413e544c424bd160599eee48cfeefa1e0
 SHA512:
-  metadata.gz: fab5f10f8233cec7793b019d427a483f8f0f71dcce16f8661cfb595388fbda72dac8d99fa3f068c4dd6aa24c16c4330bc4111108436c79d294d963b99ae88bee
-  data.tar.gz: f896ed13b17abd4e483a0a3334d0add82e199cc3c68194932b1c6ae04cfd6f6ce0a48dae475e49cfe86a3e9fe1f61a7b17aeb07f3acb040da9585e15d6e155db
+  metadata.gz: ac5bbdffd2be7bb1c8c795eff3e8c332212fd19f033805076af2eee3c11d39ac1d614927dda68997498ed2dc96d929b71c865b7b2f5babbf52283085a807f1c9
+  data.tar.gz: 86d82cbeb9b56c7d4046c474e1880fb25c3dd32522a88f39fd3c0bb697b81d17641a4a5a7ac1603bcf319f18d513d429bbaea0ad1653cd29433ad51b0c9da195

data/lib/spoom/deadcode/remover.rb

@@ -48,8 +48,10 @@ module Spoom
 
           node = @node_context.node
           case node
-          when Prism::ClassNode, Prism::ModuleNode, Prism::DefNode
+          when Prism::ClassNode, Prism::ModuleNode
             delete_node_and_comments_and_sigs(@node_context)
+          when Prism::DefNode
+            delete_node_and_comments_and_sigs(modifier_call_context(node) || @node_context)
           when Prism::ConstantWriteNode, Prism::ConstantOperatorWriteNode,
                 Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode,
                 Prism::ConstantPathWriteNode, Prism::ConstantPathOperatorWriteNode,
@@ -65,6 +67,47 @@ module Spoom
 
         private
 
+        # When a method is defined as the argument of a modifier call (e.g. `private def foo; end` or
+        # `private_class_method def self.foo; end`), the `def` node's parent is the call rather than the
+        # enclosing class or module body, so its sigs and comments are siblings of the call. Return a
+        # context targeting the outermost such call so they are removed together with the method.
+        #
+        # Modifiers are matched structurally rather than from a fixed list, so user-defined ones are
+        # handled too. A call only counts as a modifier when the `def` is its sole argument and it takes
+        # no block and is a standalone statement, so we never remove a call that does more than wrap
+        # the method (e.g. `register(:thing, def foo; end)` or `FOO = register(def foo; end)`).
+        #: (Prism::DefNode def_node) -> NodeContext?
+        def modifier_call_context(def_node)
+          wrapped = def_node #: Prism::Node
+          nesting = @node_context.nesting.dup
+          outer_call = nil #: Prism::CallNode?
+          outer_nesting = nil #: Array[Prism::Node]?
+
+          while (ancestor = nesting.pop)
+            case ancestor
+            when Prism::ArgumentsNode
+              # An arguments node sits between a call and its arguments, keep climbing
+              next
+            when Prism::CallNode
+              # Stop unless the call wraps the node as its sole argument and takes no block, otherwise
+              # it does more than wrap the method and we must not remove it
+              args = ancestor.arguments&.arguments
+              break if ancestor.block
+              break unless args && args.size == 1 && args.first.equal?(wrapped)
+
+              wrapped = ancestor
+              outer_call = ancestor
+              outer_nesting = nesting.dup
+            else
+              break
+            end
+          end
+          return unless outer_call && outer_nesting
+          return unless outer_nesting.last.is_a?(Prism::StatementsNode)
+
+          NodeContext.new(@old_source, @node_context.comments, outer_call, outer_nesting)
+        end
+
         #: (NodeContext context) -> void
         def delete_constant_assignment(context)
           case context.node

data/lib/spoom/rbs.rb

@@ -68,7 +68,12 @@ module Spoom
       end
     end
 
-    class Annotation < Comment; end
+    class Annotation < Comment
+      #: () -> bool
+      def abstract?
+        @string == "@abstract"
+      end
+    end
 
     class Signature < Comment
       # Locations of the `#|` continuation comment lines that make up a multiline signature,

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

@@ -25,6 +25,7 @@ module Spoom
             end #: Integer?
 
             @overloads_strategy = options.overloads_strategy #: Symbol
+            @translate_abstract_methods = options.translate_abstract_methods #: bool
             @type_translator = RBI::RBS::TypeTranslator.new #: RBI::RBS::TypeTranslator
           end
 
@@ -141,6 +142,7 @@ module Spoom
           def rewrite_def(def_node, comments)
             return if comments.empty?
             return if comments.signatures.empty?
+            return if !@translate_abstract_methods && comments.method_annotations.any?(&:abstract?)
 
             signatures = apply_overloads_strategy(
               comments.signatures,

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

@@ -47,13 +47,18 @@ module Spoom
           #: BaseRBIFormat
           attr_reader :output_format
 
+          #: bool
+          attr_reader :translate_abstract_methods
+
           #: (
           #|   ?overloads_strategy: Symbol,
           #|   ?output_format: BaseRBIFormat,
+          #|   ?translate_abstract_methods: bool,
           #| ) -> void
           def initialize(
             overloads_strategy: :translate_all,
-            output_format: HumanReadableRBIFormat.default
+            output_format: HumanReadableRBIFormat.default,
+            translate_abstract_methods: true
           )
             unless ALLOWED_OVERLOAD_STRATEGIES.include?(overloads_strategy)
               raise ArgumentError, "Unknown overloads_strategy: #{overloads_strategy.inspect}. " \
@@ -62,6 +67,7 @@ module Spoom
 
             @overloads_strategy = overloads_strategy
             @output_format = output_format
+            @translate_abstract_methods = translate_abstract_methods
 
             freeze
           end

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

@@ -103,10 +103,12 @@ module Spoom
           # Otherwise, replace up to the end of the node
           end_offset = comment_end_offset || node.location.end_offset
 
+          heredoc_body = heredoc_body_within_range(value, end_offset)
+
           replacement = if node.name == :bind
             "#{rbs_annotation}#{trailing_comment}"
           else
-            "#{dedent_value(node, value)} #{rbs_annotation}#{trailing_comment}"
+            "#{dedent_value(node, value)} #{rbs_annotation}#{trailing_comment}#{heredoc_body}"
           end
 
           @rewriter << Source::Replace.new(start_offset, end_offset - 1, replacement)
@@ -212,6 +214,53 @@ module Spoom
           [" #{range.pack("C*")}", end_offset]
         end
 
+        #: (Prism::Node, Integer) -> String?
+        def heredoc_body_within_range(node, replace_end_offset)
+          heredoc_end = heredoc_end_offsets(node)
+            .select { |offset| offset <= replace_end_offset }
+            .max
+          return unless heredoc_end
+
+          opener_line_end = adjust_to_line_end(node.location.end_offset)
+          body_bytes = @ruby_bytes[(opener_line_end + 1)...heredoc_end] #: as !nil
+          body = body_bytes.pack("C*")
+          body.chomp! if @ruby_bytes[replace_end_offset] == LINE_BREAK
+          "\n#{body}"
+        end
+
+        #: (Prism::Node) -> Array[Integer]
+        def heredoc_end_offsets(node)
+          offsets = [] #: Array[Integer]
+
+          case node
+          when Prism::StringNode, Prism::InterpolatedStringNode, Prism::XStringNode, Prism::InterpolatedXStringNode
+            opening = node.opening_loc
+            closing = node.closing_loc
+            if opening && closing && opening.start_line != closing.start_line && opening.slice.start_with?("<<")
+              offsets << closing.end_offset
+            end
+          end
+
+          node.child_nodes.each do |child|
+            next unless child
+
+            offsets.concat(heredoc_end_offsets(child))
+          end
+
+          offsets
+        end
+
+        #: (Prism::Node) -> bool
+        def string_literal?(node)
+          case node
+          when Prism::StringNode, Prism::InterpolatedStringNode,
+               Prism::XStringNode, Prism::InterpolatedXStringNode
+            true
+          else
+            false
+          end
+        end
+
         #: (Prism::Node, Prism::Node) -> String
         def dedent_value(assign, value)
           if value.location.start_line == assign.location.start_line
@@ -243,7 +292,7 @@ module Spoom
           # ```
           indent = value.location.start_line - assign.location.start_line
           lines = value.slice.lines
-          if lines.size > 1
+          if lines.size > 1 && !string_literal?(value)
             lines[1..]&.each_with_index do |line, i|
               lines[i + 1] = line.delete_prefix("  " * indent)
             end

data/lib/spoom/version.rb

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

data/rbi/spoom.rbi

@@ -1519,6 +1519,9 @@ class Spoom::Deadcode::Remover::NodeRemover
   end
   def insert_accessor(node, send_context, was_removed:); end
 
+  sig { params(def_node: ::Prism::DefNode).returns(T.nilable(::Spoom::Deadcode::Remover::NodeContext)) }
+  def modifier_call_context(def_node); end
+
   sig { params(start_char: ::Integer, end_char: ::Integer, replacement: ::String).void }
   def replace_chars(start_char, end_char, replacement); end
 
@@ -2575,7 +2578,11 @@ end
 module Spoom::PrismTypes; end
 Spoom::PrismTypes::AnyScopeNode = T.type_alias { T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode) }
 module Spoom::RBS; end
-class Spoom::RBS::Annotation < ::Spoom::RBS::Comment; end
+
+class Spoom::RBS::Annotation < ::Spoom::RBS::Comment
+  sig { returns(T::Boolean) }
+  def abstract?; end
+end
 
 class Spoom::RBS::Comment
   sig { params(string: ::String, location: ::Prism::Location).void }
@@ -3206,10 +3213,11 @@ class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options
   sig do
     params(
       overloads_strategy: ::Symbol,
-      output_format: ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat
+      output_format: ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat,
+      translate_abstract_methods: T::Boolean
     ).void
   end
-  def initialize(overloads_strategy: T.unsafe(nil), output_format: T.unsafe(nil)); end
+  def initialize(overloads_strategy: T.unsafe(nil), output_format: T.unsafe(nil), translate_abstract_methods: T.unsafe(nil)); end
 
   sig { returns(::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat) }
   def output_format; end
@@ -3217,6 +3225,9 @@ class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options
   sig { returns(::Symbol) }
   def overloads_strategy; end
 
+  sig { returns(T::Boolean) }
+  def translate_abstract_methods; end
+
   class << self
     sig { returns(::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options) }
     def default; end
@@ -3262,9 +3273,18 @@ class Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments < ::Spoom::Sorbet:
   sig { params(node: ::Prism::Node).returns(T::Boolean) }
   def has_rbs_annotation?(node); end
 
+  sig { params(node: ::Prism::Node, replace_end_offset: ::Integer).returns(T.nilable(::String)) }
+  def heredoc_body_within_range(node, replace_end_offset); end
+
+  sig { params(node: ::Prism::Node).returns(T::Array[::Integer]) }
+  def heredoc_end_offsets(node); end
+
   sig { params(node: ::Prism::Node).returns(T::Boolean) }
   def maybe_translate_assertion(node); end
 
+  sig { params(node: ::Prism::Node).returns(T::Boolean) }
+  def string_literal?(node); end
+
   sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
   def t?(node); end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.8.1
+  version: 1.8.2
 platform: ruby
 authors:
 - Alexandre Terrasa