rubocop-rails 2.7.0 → 2.9.1

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

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

@@ -16,7 +16,8 @@ module RuboCop
       #  class MyMailer < ActionMailer::Base
       #    # ...
       #  end
-      class ApplicationMailer < Cop
+      class ApplicationMailer < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         minimum_target_rails_version 5.0
@@ -28,12 +29,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_record.rb

@@ -16,7 +16,8 @@ module RuboCop
       #  class Rails4Model < ActiveRecord::Base
       #    # ...
       #  end
-      class ApplicationRecord < Cop
+      class ApplicationRecord < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         minimum_target_rails_version 5.0
@@ -28,12 +29,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/arel_star.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop prevents usage of `"*"` on an Arel::Table column reference.
+      #
+      # Using `arel_table["*"]` causes the outputted string to be a literal
+      # quoted asterisk (e.g. <tt>`my_model`.`*`</tt>). This causes the
+      # database to look for a column named <tt>`*`</tt> (or `"*"`) as opposed
+      # to expanding the column list as one would likely expect.
+      #
+      # @example
+      #   # bad
+      #   MyTable.arel_table["*"]
+      #
+      #   # good
+      #   MyTable.arel_table[Arel.star]
+      #
+      class ArelStar < Base
+        extend AutoCorrector
+
+        MSG = 'Use `Arel.star` instead of `"*"` for expanded column lists.'
+
+        RESTRICT_ON_SEND = %i[[]].freeze
+
+        def_node_matcher :star_bracket?, <<~PATTERN
+          (send {const (send _ :arel_table)} :[] $(str "*"))
+        PATTERN
+
+        def on_send(node)
+          return unless (star = star_bracket?(node))
+
+          add_offense(star) do |corrector|
+            corrector.replace(star.loc.expression, 'Arel.star')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,23 +13,21 @@ module RuboCop
       #   # good
       #   assert_not x
       #
-      class AssertNot < RuboCop::Cop::Cop
+      class AssertNot < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `assert_not` over `assert !`.'
+        RESTRICT_ON_SEND = %i[assert].freeze
 
         def_node_matcher :offensive?, '(send nil? :assert (send ... :!) ...)'
 
         def on_send(node)
-          add_offense(node) if offensive?(node)
-        end
+          return unless offensive?(node)
 
-        def autocorrect(node)
-          expression = node.loc.expression
+          add_offense(node) do |corrector|
+            expression = node.loc.expression
 
-          lambda do |corrector|
-            corrector.replace(
-              expression,
-              corrected_source(expression.source)
-            )
+            corrector.replace(expression, corrected_source(expression.source))
           end
         end
 

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for `attribute` class methods that specify a `:default` option
+      # which value is an array, string literal or method call without a block.
+      # It will accept all other values, such as string, symbol, integer and float literals
+      # as well as constants.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #     attribute :confirmed_at, :datetime, default: Time.zone.now
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     attribute :confirmed_at, :datetime, default: -> { Time.zone.now }
+      #   end
+      #
+      #   # bad
+      #   class User < ApplicationRecord
+      #     attribute :roles, :string, array: true, default: []
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     attribute :roles, :string, array: true, default: -> { [] }
+      #   end
+      #
+      #   # bad
+      #   class User < ApplicationRecord
+      #     attribute :configuration, default: {}
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     attribute :configuration, default: -> { {} }
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     attribute :role, :string, default: :customer
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     attribute :activated, :boolean, default: false
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     attribute :login_count, :integer, default: 0
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     FOO = 123
+      #     attribute :custom_attribute, :integer, default: FOO
+      #   end
+      class AttributeDefaultBlockValue < Base
+        extend AutoCorrector
+
+        MSG = 'Pass method in a block to `:default` option.'
+        RESTRICT_ON_SEND = %i[attribute].freeze
+        TYPE_OFFENDERS = %i[send array hash].freeze
+
+        def_node_matcher :default_attribute, <<~PATTERN
+          (send nil? :attribute _ ?_ (hash <$#attribute ...>))
+        PATTERN
+
+        def_node_matcher :attribute, '(pair (sym :default) $_)'
+
+        def on_send(node)
+          default_attribute(node) do |attribute|
+            value = attribute.children.last
+            return unless TYPE_OFFENDERS.any? { |type| value.type == type }
+
+            add_offense(value) do |corrector|
+              expression = default_attribute(node).children.last
+
+              corrector.replace(value, "-> { #{expression.source} }")
+            end
+          end
+        end
+      end
+    end
+  end
+end