spoom 1.2.4 → 1.3.0

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

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    module Plugins
+      class ActionMailerPreview < Base
+        extend T::Sig
+
+        ignore_classes_inheriting_from("ActionMailer::Preview")
+
+        sig { override.params(indexer: Indexer, definition: Definition).void }
+        def on_define_method(indexer, definition)
+          definition.ignored! if indexer.nesting_class_superclass_name == "ActionMailer::Preview"
+        end
+      end
+    end
+  end
+end

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

@@ -38,18 +38,16 @@ module Spoom
 
           arg = send.args.first
           case arg
-          when SyntaxTree::SymbolLiteral
-            indexer.reference_method(indexer.node_string(arg.value), send.node)
-          when SyntaxTree::VarRef
-            indexer.reference_constant(indexer.node_string(arg), send.node)
+          when Prism::SymbolNode
+            indexer.reference_method(arg.unescaped, send.node)
           end
 
           send.each_arg_assoc do |key, value|
-            key = indexer.node_string(key).delete_suffix(":")
+            key = key.slice.delete_suffix(":")
 
             case key
             when "if", "unless"
-              indexer.reference_method(indexer.symbol_string(value), send.node) if value
+              indexer.reference_method(value.slice.delete_prefix(":"), send.node) if value
             else
               indexer.reference_constant(camelize(key), send.node)
             end

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

@@ -16,27 +16,27 @@ module Spoom
 
           case send.name
           when "attribute", "attributes"
-            send.each_arg(SyntaxTree::SymbolLiteral) do |arg|
-              indexer.reference_method(indexer.node_string(arg.value), send.node)
+            send.each_arg(Prism::SymbolNode) do |arg|
+              indexer.reference_method(arg.unescaped, send.node)
             end
           when "validate", "validates", "validates!", "validates_each"
-            send.each_arg(SyntaxTree::SymbolLiteral) do |arg|
-              indexer.reference_method(indexer.node_string(arg.value), send.node)
+            send.each_arg(Prism::SymbolNode) do |arg|
+              indexer.reference_method(arg.unescaped, send.node)
             end
             send.each_arg_assoc do |key, value|
-              key = indexer.node_string(key).delete_suffix(":")
+              key = key.slice.delete_suffix(":")
 
               case key
               when "if", "unless"
-                indexer.reference_method(indexer.symbol_string(value), send.node) if value
+                indexer.reference_method(value.slice.delete_prefix(":"), send.node) if value
               else
                 indexer.reference_constant(camelize(key), send.node)
               end
             end
           when "validates_with"
             arg = send.args.first
-            if arg.is_a?(SyntaxTree::SymbolLiteral)
-              indexer.reference_constant(indexer.node_string(arg.value), send.node)
+            if arg.is_a?(Prism::SymbolNode)
+              indexer.reference_constant(arg.unescaped, send.node)
             end
           end
         end

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

@@ -73,8 +73,8 @@ module Spoom
         sig { override.params(indexer: Indexer, send: Send).void }
         def on_send(indexer, send)
           if send.recv.nil? && CALLBACKS.include?(send.name)
-            send.each_arg(SyntaxTree::SymbolLiteral) do |arg|
-              indexer.reference_method(indexer.node_string(arg.value), send.node)
+            send.each_arg(Prism::SymbolNode) do |arg|
+              indexer.reference_method(arg.unescaped, send.node)
             end
             return
           end
@@ -84,21 +84,18 @@ module Spoom
           case send.name
           when *CRUD_METHODS
             send.each_arg_assoc do |key, _value|
-              key = indexer.symbol_string(key).delete_suffix(":")
+              key = key.slice.delete_suffix(":")
               indexer.reference_method("#{key}=", send.node)
             end
           when *ARRAY_METHODS
-            send.each_arg(SyntaxTree::ArrayLiteral) do |arg|
-              args = arg.contents
-              next unless args.is_a?(SyntaxTree::Args)
+            send.each_arg(Prism::ArrayNode) do |arg|
+              arg.elements.each do |part|
+                next unless part.is_a?(Prism::HashNode)
 
-              args.parts.each do |part|
-                next unless part.is_a?(SyntaxTree::HashLiteral)
+                part.elements.each do |assoc|
+                  next unless assoc.is_a?(Prism::AssocNode)
 
-                part.assocs.each do |assoc|
-                  next unless assoc.is_a?(SyntaxTree::Assoc)
-
-                  key = indexer.symbol_string(assoc.key).delete_suffix(":")
+                  key = assoc.key.slice.delete_suffix(":")
                   indexer.reference_method("#{key}=", send.node)
                 end
               end

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

@@ -15,6 +15,17 @@ module Spoom
           "before_setup",
           "before_teardown",
         )
+
+        SETUP_AND_TEARDOWN_METHODS = T.let(["setup", "teardown"], T::Array[String])
+
+        sig { override.params(indexer: Indexer, send: Send).void }
+        def on_send(indexer, send)
+          return unless send.recv.nil? && SETUP_AND_TEARDOWN_METHODS.include?(send.name)
+
+          send.each_arg(Prism::SymbolNode) do |arg|
+            indexer.reference_method(T.must(arg.value), send.node)
+          end
+        end
       end
     end
   end

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

@@ -269,7 +269,7 @@ module Spoom
         #     return unless send.name == "dsl_method"
         #     return if send.args.empty?
         #
-        #     method_name = indexer.node_string(send.args.first).delete_prefix(":")
+        #     method_name = send.args.first.slice.delete_prefix(":")
         #     indexer.reference_method(method_name, send.node)
         #   end
         # end

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

@@ -29,16 +29,16 @@ module Spoom
           return unless send.recv.nil? && send.name == "field"
 
           arg = send.args.first
-          return unless arg.is_a?(SyntaxTree::SymbolLiteral)
+          return unless arg.is_a?(Prism::SymbolNode)
 
-          indexer.reference_method(indexer.node_string(arg.value), send.node)
+          indexer.reference_method(arg.unescaped, send.node)
 
           send.each_arg_assoc do |key, value|
-            key = indexer.node_string(key).delete_suffix(":")
+            key = key.slice.delete_suffix(":")
             next unless key == "resolver_method"
             next unless value
 
-            indexer.reference_method(indexer.symbol_string(value), send.node)
+            indexer.reference_method(value.slice.delete_prefix(":"), send.node)
           end
         end
       end

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

@@ -22,11 +22,9 @@ module Spoom
         sig { params(indexer: Indexer).returns(T::Boolean) }
         def used_as_namespace?(indexer)
           node = indexer.current_node
-          return false unless node.is_a?(SyntaxTree::ClassDeclaration) || node.is_a?(SyntaxTree::ModuleDeclaration)
+          return false unless node.is_a?(Prism::ClassNode) || node.is_a?(Prism::ModuleNode)
 
-          node.bodystmt.statements.body.any? do |stmt|
-            !stmt.is_a?(SyntaxTree::VoidStmt)
-          end
+          !!node.body
         end
       end
     end

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

@@ -27,34 +27,25 @@ module Spoom
             reference_symbol_as_constant(indexer, send, T.must(send.args.first))
           when "send", "__send__", "try"
             arg = send.args.first
-            indexer.reference_method(indexer.node_string(arg.value), send.node) if arg.is_a?(SyntaxTree::SymbolLiteral)
+            indexer.reference_method(arg.unescaped, send.node) if arg.is_a?(Prism::SymbolNode)
           when "alias_method"
             last_arg = send.args.last
 
-            name = case last_arg
-            when SyntaxTree::SymbolLiteral
-              indexer.node_string(last_arg.value)
-            when SyntaxTree::StringLiteral
-              last_arg.parts.map { |part| indexer.node_string(part) }.join
+            if last_arg.is_a?(Prism::SymbolNode) || last_arg.is_a?(Prism::StringNode)
+              indexer.reference_method(last_arg.unescaped, send.node)
             end
-
-            return unless name
-
-            indexer.reference_method(name, send.node)
           end
         end
 
         private
 
-        sig { params(indexer: Indexer, send: Send, node: SyntaxTree::Node).void }
+        sig { params(indexer: Indexer, send: Send, node: Prism::Node).void }
         def reference_symbol_as_constant(indexer, send, node)
           case node
-          when SyntaxTree::SymbolLiteral
-            name = indexer.node_string(node.value)
-            indexer.reference_constant(name, send.node)
-          when SyntaxTree::StringLiteral
-            string = T.must(indexer.node_string(node)[1..-2])
-            string.split("::").each do |name|
+          when Prism::SymbolNode
+            indexer.reference_constant(node.unescaped, send.node)
+          when Prism::StringNode
+            node.unescaped.split("::").each do |name|
               indexer.reference_constant(name, send.node) unless name.empty?
             end
           end

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

@@ -21,24 +21,18 @@ module Spoom
 
         sig { params(indexer: Indexer, definition: Definition).returns(T::Boolean) }
         def sorbet_type_member?(indexer, definition)
-          assign = indexer.nesting_node(SyntaxTree::Assign)
+          assign = indexer.nesting_node(Prism::ConstantWriteNode)
           return false unless assign
 
           value = assign.value
+          return false unless value.is_a?(Prism::CallNode)
 
-          case value
-          when SyntaxTree::MethodAddBlock
-            indexer.node_string(value.call).match?(/^(type_member|type_template)/)
-          when SyntaxTree::VCall
-            indexer.node_string(value.value).match?(/^(type_member|type_template)/)
-          else
-            false
-          end
+          value.name == :type_member || value.name == :type_template
         end
 
         sig { params(indexer: Indexer, definition: Definition).returns(T::Boolean) }
         def sorbet_enum_constant?(indexer, definition)
-          /^(::)?T::Enum$/.match?(indexer.nesting_class_superclass_name) && indexer.nesting_block_call_name == "enums"
+          /^(::)?T::Enum$/.match?(indexer.nesting_class_superclass_name) && indexer.nesting_call&.name == :enums
         end
       end
     end

data/lib/spoom/deadcode/plugins.rb

@@ -5,6 +5,7 @@ require_relative "plugins/base"
 
 require_relative "plugins/actionpack"
 require_relative "plugins/active_job"
+require_relative "plugins/action_mailer_preview"
 require_relative "plugins/action_mailer"
 require_relative "plugins/active_model"
 require_relative "plugins/active_record"