rubocop-rails 2.6.0 → 2.9.0

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,63 +18,50 @@ 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)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            if method_name?(node.first_argument)
-              replace_method_with_tag_method(corrector, node)
-              remove_first_argument(corrector, node)
-            else
-              corrector.replace(node.loc.selector, 'tag')
-            end
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
         private
 
-        def method_name?(node)
-          return false unless node.str_type? || node.sym_type?
+        def autocorrect(corrector, node)
+          if method_name?(node.first_argument)
+            range = correction_range(node)
 
-          /^[a-zA-Z_][a-zA-Z_0-9]*$/.match?(node.value)
-        end
+            rest_args = node.arguments.drop(1)
+            replacement = "tag.#{node.first_argument.value.to_s.underscore}(#{rest_args.map(&:source).join(', ')})"
 
-        def replace_method_with_tag_method(corrector, node)
-          corrector.replace(
-            node.loc.selector,
-            "tag.#{node.first_argument.value}"
-          )
+            corrector.replace(range, replacement)
+          else
+            corrector.replace(node.loc.selector, 'tag')
+          end
         end
 
-        def remove_first_argument(corrector, node)
-          if node.arguments.length > 1
-            corrector.remove(
-              range_between(child_node_beg(node, 0), child_node_beg(node, 1))
-            )
-          elsif node.arguments.length == 1
-            corrector.remove(node.arguments[0].loc.expression)
-          end
+        def method_name?(node)
+          return false unless node.str_type? || node.sym_type?
+
+          /^[a-zA-Z_][a-zA-Z_\-0-9]*$/.match?(node.value)
         end
 
-        def child_node_beg(node, index)
-          node.arguments[index].loc.expression.begin_pos
+        def correction_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
         end
       end
     end

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

@@ -40,8 +40,9 @@ module RuboCop
       #
       #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
       #   end
-      class CreateTableWithTimestamps < Cop
+      class CreateTableWithTimestamps < Base
         MSG = 'Add timestamps when creating a new table.'
+        RESTRICT_ON_SEND = %i[create_table].freeze
 
         def_node_matcher :create_table_with_block?, <<~PATTERN
           (block

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

@@ -43,7 +43,7 @@ module RuboCop
       #   Date.yesterday
       #   date.in_time_zone
       #
-      class Date < Cop
+      class Date < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
@@ -52,6 +52,8 @@ module RuboCop
         MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
                    'know nothing about the time zone in use.'
 
+        RESTRICT_ON_SEND = %i[to_time to_time_in_current_zone].freeze
+
         BAD_DAYS = %i[today current yesterday tomorrow].freeze
 
         DEPRECATED_METHODS = [
@@ -76,8 +78,7 @@ module RuboCop
 
           check_deprecated_methods(node)
 
-          add_offense(node, location: :selector,
-                            message: format(MSG_SEND, method: node.method_name))
+          add_offense(node.loc.selector, message: format(MSG_SEND, method: node.method_name))
         end
         alias on_csend on_send
 
@@ -87,10 +88,9 @@ module RuboCop
           DEPRECATED_METHODS.each do |method|
             next unless node.method?(method[:deprecated].to_sym)
 
-            add_offense(node, location: :selector,
-                              message: format(DEPRECATED_MSG,
-                                              deprecated: method[:deprecated],
-                                              relevant: method[:relevant]))
+            message = format(DEPRECATED_MSG, deprecated: method[:deprecated], relevant: method[:relevant])
+
+            add_offense(node.loc.selector, message: message)
           end
         end
 
@@ -104,10 +104,9 @@ module RuboCop
           day = method_name
           day = 'today' if method_name == 'current'
 
-          add_offense(node, location: :selector,
-                            message: format(MSG,
-                                            method_called: method_name,
-                                            day: day))
+          message = format(MSG, method_called: method_name, day: day)
+
+          add_offense(node.loc.selector, message: message)
         end
 
         def extract_method_chain(node)