rubocop-rails 2.0.1 → 2.19.1

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks that mailers subclass `ApplicationMailer` with Rails 5.0.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationMailer`
+      #   sneak into a mailer that is not purposed to inherit logic common among other mailers.
+      #
+      # @example
+      #
+      #  # good
+      #  class MyMailer < ApplicationMailer
+      #    # ...
+      #  end
+      #
+      #  # bad
+      #  class MyMailer < ActionMailer::Base
+      #    # ...
+      #  end
+      class ApplicationMailer < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.0
+
+        MSG = 'Mailers should subclass `ApplicationMailer`.'
+        SUPERCLASS = 'ApplicationMailer'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActionMailer) :Base)'
+
+        # rubocop:disable Layout/ClassStructure
+        include RuboCop::Cop::EnforceSuperclass
+        # rubocop:enable Layout/ClassStructure
+      end
+    end
+  end
+end

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

@@ -3,7 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that models subclass ApplicationRecord with Rails 5.0.
+      # Checks that models subclass `ApplicationRecord` with Rails 5.0.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationRecord`
+      #   sneak into an Active Record model that is not purposed to inherit logic common among other
+      #   Active Record models.
       #
       # @example
       #
@@ -16,24 +21,19 @@ module RuboCop
       #  class Rails4Model < ActiveRecord::Base
       #    # ...
       #  end
-      class ApplicationRecord < Cop
+      class ApplicationRecord < Base
+        extend AutoCorrector
         extend TargetRailsVersion
 
         minimum_target_rails_version 5.0
 
         MSG = 'Models should subclass `ApplicationRecord`.'
         SUPERCLASS = 'ApplicationRecord'
-        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActiveRecord) :Base)'
 
         # 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,47 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it turns a quoted `*` into
+      #   an SQL `*`, unquoted. `*` is a valid column name in certain databases
+      #   supported by Rails, and even though it is usually a mistake,
+      #   it might denote legitimate access to a column named `*`.
+      #
+      # @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, '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.source_range
 
-          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
+      # 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?(value.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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for belongs_to associations where we control whether the
+      # Looks for belongs_to associations where we control whether the
       # association is required via the deprecated `required` option instead.
       #
       # Since Rails 5, belongs_to associations are required by default and this
@@ -47,10 +47,8 @@ module RuboCop
       #   class Post < ApplicationRecord
       #     belongs_to :blog, optional: false
       #   end
-      #
-      # @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,35 +62,25 @@ 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 _
+        def_node_matcher :match_belongs_to_with_options, <<~PATTERN
+          (send _ :belongs_to ...
             (hash <$(pair (sym :required) ${true false}) ...>)
           )
         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, replacement)
             end
           end
         end

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

@@ -3,13 +3,18 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for code that can be written with simpler conditionals
+      # Checks for code that can be written with simpler conditionals
       # using `Object#blank?` defined by Active Support.
       #
       # Interaction with `Style/UnlessElse`:
       # The configuration of `NotPresent` will not produce an offense in the
-      # context of `unless else` if `Style/UnlessElse` is inabled. This is
-      # to prevent interference between the auto-correction of the two cops.
+      # context of `unless else` if `Style/UnlessElse` is enabled. This is
+      # to prevent interference between the autocorrection of the two cops.
+      #
+      # @safety
+      #   This cop is unsafe autocorrection, because `' '.empty?` returns false,
+      #   but `' '.blank?` returns true. Therefore, autocorrection is not compatible
+      #   if the receiver is a non-empty blank string, tab, or newline meta characters.
       #
       # @example NilOrEmpty: true (default)
       #   # Converts usages of `nil? || empty?` to `blank?`
@@ -53,17 +58,19 @@ 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`.'
+        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
         # (`bar || foo.empty?`) will blow up when checking
         # `(send (:nil) :== $_)`.
-        def_node_matcher :nil_or_empty?, <<-PATTERN
+        def_node_matcher :nil_or_empty?, <<~PATTERN
           (or
               {
                 (send $_ :!)
@@ -82,7 +89,7 @@ module RuboCop
 
         def_node_matcher :defining_blank?, '(def :blank? (args) ...)'
 
-        def_node_matcher :unless_present?, <<-PATTERN
+        def_node_matcher :unless_present?, <<~PATTERN
           (:if $(send $_ :present?) {nil? (...)} ...)
         PATTERN
 
@@ -93,10 +100,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 +113,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,37 +128,34 @@ 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.source_range
+          else
+            variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
+            range = node.source_range
           end
-        end
 
-        private
+          corrector.replace(range, replacement(variable1))
+        end
 
         def unless_condition(node, method_call)
           if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
+            node.loc.keyword.join(node.source_range.end)
           else
-            node.loc.expression.begin.join(method_call.loc.expression)
+            node.source_range.begin.join(method_call.source_range)
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This Cop checks whether alter queries are combinable.
+      # Checks whether alter queries are combinable.
       # If combinable queries are detected, it suggests to you
       # to use `change_table` with `bulk: true` instead.
       # This option causes the migration to generate a single
@@ -62,10 +62,7 @@ module RuboCop
       #       t.string :nickname
       #     end
       #   end
-      #
-      # @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
@@ -111,26 +108,13 @@ module RuboCop
           remove_timestamps
         ].freeze
 
-        MYSQL_COMBINABLE_TRANSFORMATIONS = %i[
-          rename
-          index
-          remove_index
-        ].freeze
+        MYSQL_COMBINABLE_TRANSFORMATIONS = %i[rename index remove_index].freeze
 
-        MYSQL_COMBINABLE_ALTER_METHODS = %i[
-          rename_column
-          add_index
-          remove_index
-        ].freeze
+        MYSQL_COMBINABLE_ALTER_METHODS = %i[rename_column add_index remove_index].freeze
 
-        POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[
-          change_default
-        ].freeze
+        POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[change_default].freeze
 
-        POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[
-          change_column_default
-          change_column_null
-        ].freeze
+        POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[change_column_default].freeze
 
         def on_def(node)
           return unless support_bulk_alter?
@@ -139,9 +123,9 @@ module RuboCop
 
           recorder = AlterMethodsRecorder.new
 
-          node.body.each_child_node(:send) do |send_node|
-            if combinable_alter_methods.include?(send_node.method_name)
-              recorder.process(send_node)
+          node.body.child_nodes.each do |child_node|
+            if call_to_combinable_alter_method? child_node
+              recorder.process(child_node)
             else
               recorder.flush
             end
@@ -156,25 +140,38 @@ module RuboCop
           return if include_bulk_options?(node)
           return unless node.block_node
 
-          send_nodes = node.block_node.body.each_child_node(:send).to_a
+          send_nodes = send_nodes_from_change_table_block(node.block_node.body)
 
-          transformations = send_nodes.select do |send_node|
-            combinable_transformations.include?(send_node.method_name)
-          end
-
-          add_offense_for_change_table(node) if transformations.size > 1
+          add_offense_for_change_table(node) if count_transformations(send_nodes) > 1
         end
 
         private
 
+        def send_nodes_from_change_table_block(body)
+          if body.send_type?
+            [body]
+          else
+            body.each_child_node(:send).to_a
+          end
+        end
+
+        def count_transformations(send_nodes)
+          send_nodes.sum do |node|
+            if node.method?(:remove)
+              node.arguments.count { |arg| !arg.hash_type? }
+            else
+              combinable_transformations.include?(node.method_name) ? 1 : 0
+            end
+          end
+        end
+
         # @param node [RuboCop::AST::SendNode] (send nil? :change_table ...)
         def include_bulk_options?(node)
           # arguments: [{(sym :table)(str "table")} (hash (pair (sym :bulk) _))]
           options = node.arguments[1]
           return false unless options
 
-          options.hash_type? &&
-            options.keys.any? { |key| key.sym_type? && key.value == :bulk }
+          options.hash_type? && options.keys.any? { |key| key.sym_type? && key.value == :bulk }
         end
 
         def database
@@ -195,7 +192,11 @@ module RuboCop
         def database_yaml
           return nil unless File.exist?('config/database.yml')
 
-          yaml = YAML.load_file('config/database.yml')
+          yaml = if YAML.respond_to?(:unsafe_load_file)
+                   YAML.unsafe_load_file('config/database.yml')
+                 else
+                   YAML.load_file('config/database.yml')
+                 end
           return nil unless yaml.is_a? Hash
 
           config = yaml['development']
@@ -212,13 +213,17 @@ module RuboCop
             true
           when POSTGRESQL
             # Add bulk alter support for PostgreSQL in 5.2.0
-            # @see https://github.com/rails/rails/pull/31331
+            # See: https://github.com/rails/rails/pull/31331
             target_rails_version >= 5.2
           else
             false
           end
         end
 
+        def call_to_combinable_alter_method?(child_node)
+          child_node.send_type? && combinable_alter_methods.include?(child_node.method_name)
+        end
+
         def combinable_alter_methods
           case database
           when MYSQL