rubocop-rails 2.7.1 → 2.10.0

data/lib/rubocop/cop/mixin/index_method.rb

@@ -4,10 +4,18 @@ module RuboCop
   module Cop
     # Common functionality for Rails/IndexBy and Rails/IndexWith
     module IndexMethod # rubocop:disable Metrics/ModuleLength
+      RESTRICT_ON_SEND = %i[each_with_object to_h map collect []].freeze
+
       def on_block(node)
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end
+
+        return if target_ruby_version < 2.6
+
+        on_bad_to_h(node) do |*match|
+          handle_possible_offense(node, match, 'to_h { ... }')
+        end
       end
 
       def on_send(node)
@@ -26,13 +34,6 @@ module RuboCop
         end
       end
 
-      def autocorrect(node)
-        lambda do |corrector|
-          correction = prepare_correction(node)
-          execute_correction(corrector, node, correction)
-        end
-      end
-
       private
 
       # @abstract Implemented with `def_node_matcher`
@@ -40,6 +41,11 @@ module RuboCop
         raise NotImplementedError
       end
 
+      # @abstract Implemented with `def_node_matcher`
+      def on_bad_to_h(_node)
+        raise NotImplementedError
+      end
+
       # @abstract Implemented with `def_node_matcher`
       def on_bad_map_to_h(_node)
         raise NotImplementedError
@@ -56,9 +62,11 @@ module RuboCop
         return if captures.noop_transformation?
 
         add_offense(
-          node,
-          message: "Prefer `#{new_method_name}` over `#{match_desc}`."
-        )
+          node, message: "Prefer `#{new_method_name}` over `#{match_desc}`."
+        ) do |corrector|
+          correction = prepare_correction(node)
+          execute_correction(corrector, node, correction)
+        end
       end
 
       def extract_captures(match)
@@ -73,6 +81,8 @@ module RuboCop
       def prepare_correction(node)
         if (match = on_bad_each_with_object(node))
           Autocorrection.from_each_with_object(node, match)
+        elsif (match = on_bad_to_h(node))
+          Autocorrection.from_to_h(node, match)
         elsif (match = on_bad_map_to_h(node))
           Autocorrection.from_map_to_h(node, match)
         elsif (match = on_bad_hash_brackets_map(node))
@@ -106,11 +116,15 @@ module RuboCop
       end
 
       # Internal helper class to hold autocorrect data
-      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do # rubocop:disable Metrics/BlockLength
+      Autocorrection = Struct.new(:match, :block_node, :leading, :trailing) do
         def self.from_each_with_object(node, match)
           new(match, node, 0, 0)
         end
 
+        def self.from_to_h(node, match)
+          new(match, node, 0, 0)
+        end
+
         def self.from_map_to_h(node, match)
           strip_trailing_chars = 0
 

data/lib/rubocop/cop/rails/action_filter.rb

@@ -29,8 +29,9 @@ module RuboCop
       #   after_filter :do_stuff
       #   append_around_filter :do_stuff
       #   skip_after_filter :do_stuff
-      class ActionFilter < Cop
+      class ActionFilter < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
 
@@ -66,6 +67,8 @@ module RuboCop
           skip_action_callback
         ].freeze
 
+        RESTRICT_ON_SEND = FILTER_METHODS + ACTION_METHODS
+
         def on_block(node)
           check_method_node(node.send_node)
         end
@@ -74,24 +77,17 @@ module RuboCop
           check_method_node(node) unless node.receiver
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.selector,
-                              preferred_method(node.loc.selector.source).to_s)
-          end
-        end
-
         private
 
         def check_method_node(node)
-          return unless bad_methods.include?(node.method_name)
+          method_name = node.method_name
+          return unless bad_methods.include?(method_name)
 
-          add_offense(node, location: :selector)
-        end
+          message = format(MSG, prefer: preferred_method(method_name), current: method_name)
 
-        def message(node)
-          format(MSG, prefer: preferred_method(node.method_name),
-                      current: node.method_name)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.loc.selector, preferred_method(node.loc.selector.source))
+          end
         end
 
         def bad_methods

data/lib/rubocop/cop/rails/active_record_aliases.rb

@@ -12,7 +12,9 @@ module RuboCop
       #
       #   #good
       #   Book.update!(author: 'Alice')
-      class ActiveRecordAliases < Cop
+      class ActiveRecordAliases < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         ALIASES = {
@@ -20,28 +22,22 @@ module RuboCop
           update_attributes!: :update!
         }.freeze
 
+        RESTRICT_ON_SEND = ALIASES.keys.freeze
+
         def on_send(node)
-          ALIASES.each do |bad, good|
-            next unless node.method?(bad)
+          method_name = node.method_name
+          alias_method = ALIASES[method_name]
 
-            add_offense(node,
-                        message: format(MSG, prefer: good, current: bad),
-                        location: :selector,
-                        severity: :warning)
-            break
+          add_offense(
+            node.loc.selector,
+            message: format(MSG, prefer: alias_method, current: method_name),
+            severity: :warning
+          ) do |corrector|
+            corrector.replace(node.loc.selector, alias_method)
           end
         end
 
         alias on_csend on_send
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node.loc.selector,
-              ALIASES[node.method_name].to_s
-            )
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/rails/active_record_callbacks_order.rb

@@ -19,7 +19,9 @@ module RuboCop
       #     after_commit :after_commit_callback
       #   end
       #
-      class ActiveRecordCallbacksOrder < Cop
+      class ActiveRecordCallbacksOrder < Base
+        extend AutoCorrector
+
         MSG = '`%<current>s` is supposed to appear before `%<previous>s`.'
 
         CALLBACKS_IN_ORDER = %i[
@@ -44,9 +46,7 @@ module RuboCop
           after_touch
         ].freeze
 
-        CALLBACKS_ORDER_MAP = Hash[
-          CALLBACKS_IN_ORDER.map.with_index { |name, index| [name, index] }
-        ].freeze
+        CALLBACKS_ORDER_MAP = CALLBACKS_IN_ORDER.each_with_index.to_h.freeze
 
         def on_class(class_node)
           previous_index = -1
@@ -57,32 +57,31 @@ module RuboCop
             index = CALLBACKS_ORDER_MAP[callback]
 
             if index < previous_index
-              message = format(MSG, current: callback,
-                                    previous: previous_callback)
-              add_offense(node, message: message)
+              message = format(MSG, current: callback, previous: previous_callback)
+              add_offense(node, message: message) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
             previous_index = index
             previous_callback = callback
           end
         end
 
+        private
+
         # Autocorrect by swapping between two nodes autocorrecting them
-        def autocorrect(node)
-          previous = left_siblings_of(node).find do |sibling|
+        def autocorrect(corrector, node)
+          previous = left_siblings_of(node).reverse_each.find do |sibling|
             callback?(sibling)
           end
 
           current_range = source_range_with_comment(node)
           previous_range = source_range_with_comment(previous)
 
-          lambda do |corrector|
-            corrector.insert_before(previous_range, current_range.source)
-            corrector.remove(current_range)
-          end
+          corrector.insert_before(previous_range, current_range.source)
+          corrector.remove(current_range)
         end
 
-        private
-
         def defined_callbacks(class_node)
           class_def = class_node.body
 
@@ -123,7 +122,7 @@ module RuboCop
 
           processed_source.comments_before_line(annotation_line)
                           .reverse_each do |comment|
-            if comment.location.line == annotation_line
+            if comment.location.line == annotation_line && !inline_comment?(comment)
               first_comment = comment
               annotation_line -= 1
             end
@@ -132,6 +131,10 @@ module RuboCop
           start_line_position(first_comment || node)
         end
 
+        def inline_comment?(comment)
+          !comment_line?(comment.loc.expression.source_line)
+        end
+
         def start_line_position(node)
           buffer.line_range(node.loc.line).begin_pos - 1
         end

data/lib/rubocop/cop/rails/active_record_override.rb

@@ -24,7 +24,7 @@ module RuboCop
       #     end
       #   end
       #
-      class ActiveRecordOverride < Cop
+      class ActiveRecordOverride < Base
         MSG =
           'Use %<prefer>s callbacks instead of overriding the Active Record ' \
           'method `%<bad>s`.'

data/lib/rubocop/cop/rails/active_support_aliases.rb

@@ -19,8 +19,11 @@ module RuboCop
       #   [1, 2, 'a'].append('b')
       #   [1, 2, 'a'].prepend('b')
       #
-      class ActiveSupportAliases < Cop
+      class ActiveSupportAliases < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[starts_with? ends_with? append prepend].freeze
 
         ALIASES = {
           starts_with?: {
@@ -39,29 +42,17 @@ module RuboCop
 
         def on_send(node)
           ALIASES.each_key do |aliased_method|
-            register_offense(node, aliased_method) if
-              public_send(aliased_method, node)
-          end
-        end
+            next unless public_send(aliased_method, node)
 
-        def autocorrect(node)
-          return false if append(node)
+            preferred_method = ALIASES[aliased_method][:original]
+            message = format(MSG, prefer: preferred_method, current: aliased_method)
 
-          lambda do |corrector|
-            method_name = node.loc.selector.source
-            replacement = ALIASES[method_name.to_sym][:original]
-            corrector.replace(node.loc.selector, replacement.to_s)
-          end
-        end
-
-        private
+            add_offense(node, message: message) do |corrector|
+              next if append(node)
 
-        def register_offense(node, method_name)
-          add_offense(
-            node,
-            message: format(MSG, prefer: ALIASES[method_name][:original],
-                                 current: method_name)
-          )
+              corrector.replace(node.loc.selector, preferred_method)
+            end
+          end
         end
       end
     end

data/lib/rubocop/cop/rails/after_commit_override.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces that there is only one call to `after_commit`
+      # (and its aliases - `after_create_commit`, `after_update_commit`,
+      # and `after_destroy_commit`) with the same callback name per model.
+      #
+      # @example
+      #   # bad
+      #   # This won't be triggered.
+      #   after_create_commit :log_action
+      #
+      #   # This will override the callback added by
+      #   # after_create_commit.
+      #   after_update_commit :log_action
+      #
+      #   # bad
+      #   # This won't be triggered.
+      #   after_commit :log_action, on: :create
+      #   # This won't be triggered.
+      #   after_update_commit :log_action
+      #   # This will override both previous callbacks.
+      #   after_commit :log_action, on: :destroy
+      #
+      #   # good
+      #   after_save_commit :log_action
+      #
+      #   # good
+      #   after_create_commit :log_create_action
+      #   after_update_commit :log_update_action
+      #
+      class AfterCommitOverride < Base
+        MSG = 'There can only be one `after_*_commit :%<name>s` hook defined for a model.'
+
+        AFTER_COMMIT_CALLBACKS = %i[
+          after_commit
+          after_create_commit
+          after_update_commit
+          after_save_commit
+          after_destroy_commit
+        ].freeze
+
+        def on_class(class_node)
+          seen_callback_names = {}
+
+          each_after_commit_callback(class_node) do |node|
+            callback_name = node.arguments[0].value
+            if seen_callback_names.key?(callback_name)
+              add_offense(node, message: format(MSG, name: callback_name))
+            else
+              seen_callback_names[callback_name] = true
+            end
+          end
+        end
+
+        private
+
+        def each_after_commit_callback(class_node)
+          class_send_nodes(class_node).each do |node|
+            yield node if after_commit_callback?(node) && named_callback?(node)
+          end
+        end
+
+        def class_send_nodes(class_node)
+          class_def = class_node.body
+
+          return [] unless class_def
+
+          if class_def.send_type?
+            [class_def]
+          else
+            class_def.each_child_node(:send).to_a
+          end
+        end
+
+        def after_commit_callback?(node)
+          AFTER_COMMIT_CALLBACKS.include?(node.method_name)
+        end
+
+        def named_callback?(node)
+          name = node.first_argument
+          return false unless name
+
+          name.sym_type?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/application_controller.rb

@@ -16,7 +16,9 @@ module RuboCop
       #  class MyController < ActionController::Base
       #    # ...
       #  end
-      class ApplicationController < Cop
+      class ApplicationController < Base
+        extend AutoCorrector
+
         MSG = 'Controllers should subclass `ApplicationController`.'
         SUPERCLASS = 'ApplicationController'
         BASE_PATTERN = '(const (const nil? :ActionController) :Base)'
@@ -24,12 +26,6 @@ module RuboCop
         # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass
         # rubocop:enable Layout/ClassStructure
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, self.class::SUPERCLASS)
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/rails/application_job.rb

@@ -16,7 +16,8 @@ module RuboCop
       #  class Rails4Job < ActiveJob::Base
       #    # ...
       #  end
-      class ApplicationJob < Cop
+      class ApplicationJob < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         minimum_target_rails_version 5.0