rubocop-rails 2.8.1 → 2.9.0

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

@@ -31,7 +31,7 @@ module RuboCop
       #   after_create_commit :log_create_action
       #   after_update_commit :log_update_action
       #
-      class AfterCommitOverride < Cop
+      class AfterCommitOverride < Base
         MSG = 'There can only be one `after_*_commit :%<name>s` hook defined for a model.'
 
         AFTER_COMMIT_CALLBACKS = %i[

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

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

@@ -50,7 +50,8 @@ module RuboCop
       #
       # @see https://guides.rubyonrails.org/5_0_release_notes.html
       # @see https://github.com/rails/rails/pull/18937
-      class BelongsTo < Cop
+      class BelongsTo < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         minimum_target_rails_version 5.0
@@ -64,6 +65,7 @@ module RuboCop
           'option is deprecated and you want to use `optional: false`. ' \
           'In most configurations, this is the default and you can omit ' \
           'this option altogether'
+        RESTRICT_ON_SEND = %i[belongs_to].freeze
 
         def_node_matcher :match_belongs_to_with_options, <<~PATTERN
           (send _ :belongs_to _
@@ -72,27 +74,16 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          match_belongs_to_with_options(node) do |_option_node, option_value|
-            message =
+          match_belongs_to_with_options(node) do |option_node, option_value|
+            message, replacement =
               if option_value.true_type?
-                SUPERFLOUS_REQUIRE_TRUE_MSG
+                [SUPERFLOUS_REQUIRE_TRUE_MSG, 'optional: false']
               elsif option_value.false_type?
-                SUPERFLOUS_REQUIRE_FALSE_MSG
+                [SUPERFLOUS_REQUIRE_FALSE_MSG, 'optional: true']
               end
 
-            add_offense(node, message: message, location: :selector)
-          end
-        end
-
-        def autocorrect(node)
-          option_node, option_value = match_belongs_to_with_options(node)
-          return unless option_node
-
-          lambda do |corrector|
-            if option_value.true_type?
-              corrector.replace(option_node.loc.expression, 'optional: false')
-            elsif option_value.false_type?
-              corrector.replace(option_node.loc.expression, 'optional: true')
+            add_offense(node.loc.selector, message: message) do |corrector|
+              corrector.replace(option_node.loc.expression, replacement)
             end
           end
         end

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

@@ -53,11 +53,14 @@ module RuboCop
       #   def blank?
       #     !present?
       #   end
-      class Blank < Cop
+      class Blank < Base
+        extend AutoCorrector
+
         MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'
         MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'
         MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of ' \
                              '`%<current>s`.'
+        RESTRICT_ON_SEND = %i[!].freeze
 
         # `(send nil $_)` is not actually a valid match for an offense. Nodes
         # that have a single method call on the left hand side
@@ -93,10 +96,10 @@ module RuboCop
             # accepts !present? if its in the body of a `blank?` method
             next if defining_blank?(node.parent)
 
-            add_offense(node,
-                        message: format(MSG_NOT_PRESENT,
-                                        prefer: replacement(receiver),
-                                        current: node.source))
+            message = format(MSG_NOT_PRESENT, prefer: replacement(receiver), current: node.source)
+            add_offense(node, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -106,10 +109,10 @@ module RuboCop
           nil_or_empty?(node) do |var1, var2|
             return unless var1 == var2
 
-            add_offense(node,
-                        message: format(MSG_NIL_OR_EMPTY,
-                                        prefer: replacement(var1),
-                                        current: node.source))
+            message = format(MSG_NIL_OR_EMPTY, prefer: replacement(var1), current: node.source)
+            add_offense(node, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -121,31 +124,28 @@ module RuboCop
           unless_present?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)
 
-            add_offense(node,
-                        location: range,
-                        message: format(MSG_UNLESS_PRESENT,
-                                        prefer: replacement(receiver),
-                                        current: range.source))
+            message = format(MSG_UNLESS_PRESENT, prefer: replacement(receiver), current: range.source)
+            add_offense(range, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            method_call, variable1 = unless_present?(node)
+        private
 
-            if method_call
-              corrector.replace(node.loc.keyword, 'if')
-              range = method_call.loc.expression
-            else
-              variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
-              range = node.loc.expression
-            end
+        def autocorrect(corrector, node)
+          method_call, variable1 = unless_present?(node)
 
-            corrector.replace(range, replacement(variable1))
+          if method_call
+            corrector.replace(node.loc.keyword, 'if')
+            range = method_call.loc.expression
+          else
+            variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
+            range = node.loc.expression
           end
-        end
 
-        private
+          corrector.replace(range, replacement(variable1))
+        end
 
         def unless_condition(node, method_call)
           if node.modifier_form?

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

@@ -65,7 +65,7 @@ module RuboCop
       #
       # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
       # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
-      class BulkChangeTable < Cop
+      class BulkChangeTable < Base
         MSG_FOR_CHANGE_TABLE = <<~MSG.chomp
           You can combine alter queries using `bulk: true` options.
         MSG

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

@@ -18,42 +18,42 @@ module RuboCop
       #  tag.p('Hello world!')
       #  tag.br
       #  content_tag(name, 'Hello world!')
-      class ContentTag < Cop
+      class ContentTag < Base
         include RangeHelp
+        extend AutoCorrector
         extend TargetRailsVersion
 
         minimum_target_rails_version 5.1
 
         MSG = 'Use `tag` instead of `content_tag`.'
+        RESTRICT_ON_SEND = %i[content_tag].freeze
 
         def on_send(node)
-          return unless node.method?(:content_tag)
-
           first_argument = node.first_argument
           return unless first_argument
 
           return if first_argument.variable? || first_argument.send_type? || first_argument.const_type?
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if method_name?(node.first_argument)
-              range = correction_range(node)
+        private
+
+        def autocorrect(corrector, node)
+          if method_name?(node.first_argument)
+            range = correction_range(node)
 
-              rest_args = node.arguments.drop(1)
-              replacement = "tag.#{node.first_argument.value.to_s.underscore}(#{rest_args.map(&:source).join(', ')})"
+            rest_args = node.arguments.drop(1)
+            replacement = "tag.#{node.first_argument.value.to_s.underscore}(#{rest_args.map(&:source).join(', ')})"
 
-              corrector.replace(range, replacement)
-            else
-              corrector.replace(node.loc.selector, 'tag')
-            end
+            corrector.replace(range, replacement)
+          else
+            corrector.replace(node.loc.selector, 'tag')
           end
         end
 
-        private
-
         def method_name?(node)
           return false unless node.str_type? || node.sym_type?