rubocop-rails 2.19.1 → 2.21.2

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Rails
-      #
       # Use `assert_not` methods instead of `refute` methods.
       #
       # @example EnforcedStyle: assert_not (default)

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

@@ -307,7 +307,7 @@ module RuboCop
 
         def within_reversible_or_up_only_block?(node)
           node.each_ancestor(:block).any? do |ancestor|
-            (ancestor.block_type? && ancestor.send_node.method?(:reversible)) || ancestor.send_node.method?(:up_only)
+            (ancestor.block_type? && ancestor.method?(:reversible)) || ancestor.method?(:up_only)
           end
         end
 

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

@@ -12,7 +12,7 @@ module RuboCop
       # `Style/FileRead`, `Style/FileWrite` and `Rails/RootJoinChain`.
       #
       # @safety
-      #   This cop is unsafe for autocorrection because `Dir`'s `children`, `each_child`, `entries`, and `glob`
+      #   This cop is unsafe for autocorrection because ``Dir``'s `children`, `each_child`, `entries`, and `glob`
       #   methods return string element, but these methods of `Pathname` return `Pathname` element.
       #
       # @example
@@ -32,13 +32,28 @@ module RuboCop
       #   Rails.root.join('db', 'schema.rb').write(content)
       #   Rails.root.join('db', 'schema.rb').binwrite(content)
       #
-      class RootPathnameMethods < Base
+      class RootPathnameMethods < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
         include RangeHelp
 
         MSG = '`%<rails_root>s` is a `Pathname` so you can just append `#%<method>s`.'
 
-        DIR_METHODS = %i[children delete each_child empty? entries exist? glob mkdir open rmdir unlink].to_set.freeze
+        DIR_GLOB_METHODS = %i[glob].to_set.freeze
+
+        DIR_NON_GLOB_METHODS = %i[
+          children
+          delete
+          each_child
+          empty?
+          entries
+          exist?
+          mkdir
+          open
+          rmdir
+          unlink
+        ].to_set.freeze
+
+        DIR_METHODS = (DIR_GLOB_METHODS + DIR_NON_GLOB_METHODS).freeze
 
         FILE_METHODS = %i[
           atime
@@ -134,7 +149,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = (DIR_METHODS + FILE_METHODS + FILE_TEST_METHODS + FILE_UTILS_METHODS).to_set.freeze
 
-        def_node_matcher :pathname_method, <<~PATTERN
+        # @!method pathname_method_for_ruby_2_5_or_higher(node)
+        def_node_matcher :pathname_method_for_ruby_2_5_or_higher, <<~PATTERN
           {
             (send (const {nil? cbase} :Dir) $DIR_METHODS $_ $...)
             (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
@@ -143,6 +159,16 @@ module RuboCop
           }
         PATTERN
 
+        # @!method pathname_method_for_ruby_2_4_or_lower(node)
+        def_node_matcher :pathname_method_for_ruby_2_4_or_lower, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Dir) $DIR_NON_GLOB_METHODS $_ $...)
+            (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
+            (send (const {nil? cbase} :FileTest) $FILE_TEST_METHODS $_ $...)
+            (send (const {nil? cbase} :FileUtils) $FILE_UTILS_METHODS $_ $...)
+          }
+        PATTERN
+
         def_node_matcher :dir_glob?, <<~PATTERN
           (send
             (const {cbase nil?} :Dir) :glob ...)
@@ -183,6 +209,14 @@ module RuboCop
           yield(method, path, args, rails_root)
         end
 
+        def pathname_method(node)
+          if target_ruby_version >= 2.5
+            pathname_method_for_ruby_2_5_or_higher(node)
+          else
+            pathname_method_for_ruby_2_4_or_lower(node)
+          end
+        end
+
         def build_path_glob_replacement(path, method)
           receiver = range_between(path.source_range.begin_pos, path.children.first.loc.selector.end_pos).source
 

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

@@ -188,7 +188,7 @@ module RuboCop
         end
 
         def persisted_referenced?(assignment)
-          return unless assignment.referenced?
+          return false unless assignment.referenced?
 
           assignment.variable.references.any? do |reference|
             call_to_persisted?(reference.node.parent)
@@ -298,7 +298,7 @@ module RuboCop
 
           node = assignable_node(node)
           method, sibling_index = find_method_with_sibling_index(node.parent)
-          return unless method && (method.def_type? || method.block_type?)
+          return false unless method && (method.def_type? || method.block_type?)
 
           method.children.size == node.sibling_index + sibling_index
         end

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

@@ -74,17 +74,25 @@ module RuboCop
         def on_send(node)
           if add_column_without_comment?(node)
             add_offense(node, message: COLUMN_MSG)
-          elsif create_table?(node)
-            if create_table_without_comment?(node)
-              add_offense(node, message: TABLE_MSG)
-            elsif create_table_column_call_without_comment?(node)
-              add_offense(node.parent.body, message: COLUMN_MSG)
-            end
+          elsif create_table_without_comment?(node)
+            add_offense(node, message: TABLE_MSG)
+          elsif create_table_with_block?(node.parent)
+            check_column_within_create_table_block(node.parent.body)
           end
         end
 
         private
 
+        def check_column_within_create_table_block(node)
+          if node.begin_type?
+            node.child_nodes.each do |child_node|
+              add_offense(child_node, message: COLUMN_MSG) if t_column_without_comment?(child_node)
+            end
+          elsif t_column_without_comment?(node)
+            add_offense(node, message: COLUMN_MSG)
+          end
+        end
+
         def add_column_without_comment?(node)
           add_column?(node) && !add_column_with_comment?(node)
         end
@@ -93,10 +101,8 @@ module RuboCop
           create_table?(node) && !create_table_with_comment?(node)
         end
 
-        def create_table_column_call_without_comment?(node)
-          create_table_with_block?(node.parent) &&
-            t_column?(node.parent.body) &&
-            !t_column_with_comment?(node.parent.body)
+        def t_column_without_comment?(node)
+          t_column?(node) && !t_column_with_comment?(node)
         end
       end
     end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for uses of `select(:column_name)` with `map(&:column_name)`.
+      # These can be replaced with `pluck(:column_name)`.
+      #
+      # There also should be some performance improvement since it skips instantiating the model class for matches.
+      #
+      # @safety
+      #   This cop is unsafe because the model might override the attribute getter.
+      #   Additionally, the model's `after_initialize` hooks are skipped when using `pluck`.
+      #
+      # @example
+      #   # bad
+      #   Model.select(:column_name).map(&:column_name)
+      #
+      #   # good
+      #   Model.pluck(:column_name)
+      #
+      class SelectMap < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred_method>s` instead of `select` with `%<map_method>s`.'
+
+        RESTRICT_ON_SEND = %i[map collect].freeze
+
+        def on_send(node)
+          return unless node.first_argument
+
+          column_name = node.first_argument.source.delete_prefix('&:')
+          return unless (select_node = find_select_node(node, column_name))
+
+          offense_range = select_node.loc.selector.begin.join(node.source_range.end)
+          preferred_method = "pluck(:#{column_name})"
+          message = format(MSG, preferred_method: preferred_method, map_method: node.method_name)
+
+          add_offense(offense_range, message: message) do |corrector|
+            autocorrect(corrector, select_node, node, preferred_method)
+          end
+        end
+
+        private
+
+        def find_select_node(node, column_name)
+          node.descendants.detect do |select_candidate|
+            next if !select_candidate.send_type? || !select_candidate.method?(:select)
+
+            match_column_name?(select_candidate, column_name)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, select_node, node, preferred_method)
+          corrector.remove(select_node.loc.dot || node.loc.dot)
+          corrector.remove(select_node.loc.selector.begin.join(select_node.source_range.end))
+          corrector.replace(node.loc.selector.begin.join(node.source_range.end), preferred_method)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def match_column_name?(select_candidate, column_name)
+          return false unless select_candidate.arguments.one?
+          return false unless (first_argument = select_candidate.first_argument)
+
+          argument = case select_candidate.first_argument.type
+                     when :sym
+                       first_argument.source.delete_prefix(':')
+                     when :str
+                       first_argument.value if first_argument.respond_to?(:value)
+                     end
+
+          argument == column_name
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,6 @@
 module RuboCop
   module Cop
     module Rails
-      #
       # Checks SQL heredocs to use `.squish`.
       #
       # @safety

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

@@ -35,7 +35,7 @@ module RuboCop
         PATTERN
 
         def_node_search :change_column_null?, <<~PATTERN
-          (send nil? :change_column_null {(sym %1) (str %1)} {(sym %2) (str %2)} false)
+          (send nil? :change_column_null %1 %2 false)
         PATTERN
 
         def on_send(node)
@@ -46,9 +46,7 @@ module RuboCop
 
             def_node = node.each_ancestor(:def, :defs).first
             table_node = table_node(node)
-            if def_node && (table_node.nil? || change_column_null?(def_node, table_node.value, column_node.value))
-              return
-            end
+            return if def_node && (table_node.nil? || change_column_null?(def_node, table_node, column_node))
 
             add_offense(node)
           end

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

@@ -21,6 +21,7 @@ module RuboCop
       #   # bad
       #   Time.now
       #   Time.parse('2015-03-02T19:05:37')
+      #   '2015-03-02T19:05:37'.to_time
       #
       #   # good
       #   Time.current
@@ -44,18 +45,16 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` instead.'
-
         MSG_ACCEPTABLE = 'Do not use `%<current>s` without zone. Use one of %<prefer>s instead.'
-
         MSG_LOCALTIME = 'Do not use `Time.localtime` without offset or zone.'
+        MSG_STRING_TO_TIME = 'Do not use `String#to_time` without zone. Use `Time.zone.parse` instead.'
 
         GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
-
         DANGEROUS_METHODS = %i[now local new parse at].freeze
-
         ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601 jisx0301 rfc3339 httpdate to_i to_f].freeze
+        TIMEZONE_SPECIFIER = /([A-Za-z]|[+-]\d{2}:?\d{2})\z/.freeze
 
-        TIMEZONE_SPECIFIER = /([A-z]|[+-]\d{2}:?\d{2})\z/.freeze
+        RESTRICT_ON_SEND = %i[to_time].freeze
 
         def on_const(node)
           mod, klass = *node
@@ -66,6 +65,14 @@ module RuboCop
           check_time_node(klass, node.parent) if klass == :Time
         end
 
+        def on_send(node)
+          return if !node.receiver&.str_type? || !node.method?(:to_time)
+
+          add_offense(node.loc.selector, message: MSG_STRING_TO_TIME) do |corrector|
+            corrector.replace(node, "Time.zone.parse(#{node.receiver.source})")
+          end
+        end
+
         private
 
         def autocorrect(corrector, node)

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

@@ -13,6 +13,8 @@ module RuboCop
       # error when rollback is desired, and to use `next` when commit is
       # desired.
       #
+      # If you are defining custom transaction methods, you can configure it with `TransactionMethods`.
+      #
       # @example
       #   # bad
       #   ApplicationRecord.transaction do
@@ -34,6 +36,11 @@ module RuboCop
       #     throw if user.active?
       #   end
       #
+      #   # bad, as `with_lock` implicitly opens a transaction too
+      #   ApplicationRecord.with_lock do
+      #     break if user.active?
+      #   end
+      #
       #   # good
       #   ApplicationRecord.transaction do
       #     # Rollback
@@ -45,12 +52,16 @@ module RuboCop
       #     # Commit
       #     next if user.active?
       #   end
+      #
+      # @example TransactionMethods: ["custom_transaction"]
+      #   # bad
+      #   CustomModel.custom_transaction do
+      #     return if user.active?
+      #   end
+      #
       class TransactionExitStatement < Base
-        MSG = <<~MSG.chomp
-          Exit statement `%<statement>s` is not allowed. Use `raise` (rollback) or `next` (commit).
-        MSG
-
-        RESTRICT_ON_SEND = %i[transaction with_lock].freeze
+        MSG = 'Exit statement `%<statement>s` is not allowed. Use `raise` (rollback) or `next` (commit).'
+        BUILT_IN_TRANSACTION_METHODS = %i[transaction with_lock].freeze
 
         def_node_search :exit_statements, <<~PATTERN
           ({return | break | send nil? :throw} ...)
@@ -65,10 +76,9 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless (parent = node.parent)
-          return unless parent.block_type? && parent.body
+          return unless in_transaction_block?(node)
 
-          exit_statements(parent.body).each do |statement_node|
+          exit_statements(node.parent.body).each do |statement_node|
             next if statement_node.break_type? && nested_block?(statement_node)
 
             statement = statement(statement_node)
@@ -80,6 +90,13 @@ module RuboCop
 
         private
 
+        def in_transaction_block?(node)
+          return false unless transaction_method_name?(node.method_name)
+          return false unless (parent = node.parent)
+
+          parent.block_type? && parent.body
+        end
+
         def statement(statement_node)
           if statement_node.return_type?
             'return'
@@ -91,7 +108,16 @@ module RuboCop
         end
 
         def nested_block?(statement_node)
-          !statement_node.ancestors.find(&:block_type?).method?(:transaction)
+          name = statement_node.ancestors.find(&:block_type?).children.first.method_name
+          !transaction_method_name?(name)
+        end
+
+        def transaction_method_name?(method_name)
+          BUILT_IN_TRANSACTION_METHODS.include?(method_name) || transaction_method?(method_name)
+        end
+
+        def transaction_method?(method_name)
+          cop_config.fetch('TransactionMethods', []).include?(method_name.to_s)
         end
       end
     end

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

@@ -31,11 +31,11 @@ module RuboCop
         RESTRICT_ON_SEND = %i[validates].freeze
 
         def on_send(node)
-          return unless uniqueness_part(node)
-          return if condition_part?(node)
           return unless schema
+          return unless (uniqueness_part = uniqueness_part(node))
+          return if uniqueness_part.falsey_literal? || condition_part?(node, uniqueness_part)
 
-          klass, table, names = find_schema_information(node)
+          klass, table, names = find_schema_information(node, uniqueness_part)
           return unless names
           return if with_index?(klass, table, names)
 
@@ -44,12 +44,12 @@ module RuboCop
 
         private
 
-        def find_schema_information(node)
+        def find_schema_information(node, uniqueness_part)
           klass = class_node(node)
           return unless klass
 
           table = schema.table_by(name: table_name(klass))
-          names = column_names(node)
+          names = column_names(node, uniqueness_part)
 
           [klass, table, names]
         end
@@ -71,12 +71,12 @@ module RuboCop
           end
         end
 
-        def column_names(node)
+        def column_names(node, uniqueness_part)
           arg = node.first_argument
           return unless arg.str_type? || arg.sym_type?
 
           ret = [arg.value]
-          names_from_scope = column_names_from_scope(node)
+          names_from_scope = column_names_from_scope(uniqueness_part)
           ret.concat(names_from_scope) if names_from_scope
 
           ret = ret.flat_map do |name|
@@ -90,11 +90,10 @@ module RuboCop
           ret.include?(nil) ? nil : ret.to_set
         end
 
-        def column_names_from_scope(node)
-          uniq = uniqueness_part(node)
-          return unless uniq.hash_type?
+        def column_names_from_scope(uniqueness_part)
+          return unless uniqueness_part.hash_type?
 
-          scope = find_scope(uniq)
+          scope = find_scope(uniqueness_part)
           return unless scope
 
           scope = unfreeze_scope(scope)
@@ -126,7 +125,7 @@ module RuboCop
 
         def uniqueness_part(node)
           pairs = node.arguments.last
-          return unless pairs.hash_type?
+          return unless pairs&.hash_type?
 
           pairs.each_pair.find do |pair|
             next unless pair.key.sym_type? && pair.key.value == :uniqueness
@@ -135,14 +134,11 @@ module RuboCop
           end
         end
 
-        def condition_part?(node)
-          pairs = node.arguments.last
-          return unless pairs.hash_type?
-
+        def condition_part?(node, uniqueness_node)
+          pairs = node.last_argument
+          return false unless pairs.hash_type?
           return true if condition_hash_part?(pairs, keys: %i[if unless])
-
-          uniqueness_node = uniqueness_part(node)
-          return unless uniqueness_node&.hash_type?
+          return false unless uniqueness_node.hash_type?
 
           condition_hash_part?(uniqueness_node, keys: %i[if unless conditions])
         end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # If you try to render content along with a non-content status code (100-199, 204, 205, or 304),
+      # it will be dropped from the response.
+      #
+      # This cop checks for uses of `render` which specify both body content and a non-content status.
+      #
+      # @example
+      #   # bad
+      #   render 'foo', status: :continue
+      #   render status: 100, plain: 'Ruby!'
+      #
+      #   # good
+      #   head :continue
+      #   head 100
+      class UnusedRenderContent < Base
+        include RangeHelp
+
+        MSG = 'Do not specify body content for a response with a non-content status code'
+        RESTRICT_ON_SEND = %i[render].freeze
+        NON_CONTENT_STATUS_CODES = Set[*100..199, 204, 205, 304] & ::Rack::Utils::SYMBOL_TO_STATUS_CODE.values
+        NON_CONTENT_STATUSES = Set[
+          *::Rack::Utils::SYMBOL_TO_STATUS_CODE.invert.fetch_values(*NON_CONTENT_STATUS_CODES)
+        ]
+        BODY_OPTIONS = Set[
+          :action,
+          :body,
+          :content_type,
+          :file,
+          :html,
+          :inline,
+          :json,
+          :js,
+          :layout,
+          :plain,
+          :raw,
+          :template,
+          :text,
+          :xml
+        ]
+
+        def_node_matcher :non_content_status?, <<~PATTERN
+          (pair
+            (sym :status)
+            {(sym NON_CONTENT_STATUSES) (int NON_CONTENT_STATUS_CODES)}
+          )
+        PATTERN
+
+        def_node_matcher :unused_render_content?, <<~PATTERN
+          (send nil? :render {
+            (hash <#non_content_status? $(pair (sym BODY_OPTIONS) _) ...>) |
+            $({str sym} _) (hash <#non_content_status? ...>)
+          })
+        PATTERN
+
+        def on_send(node)
+          unused_render_content?(node) do |unused_content_node|
+            add_offense(unused_content_node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -39,7 +39,6 @@ module RuboCop
       #   # bad
       #   User.exists?(name: 'john')
       #   User.exists?(['name = ?', 'john'])
-      #   User.exists?('name = ?', 'john')
       #   user.posts.exists?(published: true)
       #
       #   # good

data/lib/rubocop/cop/rails_cops.rb

@@ -32,6 +32,7 @@ require_relative 'rails/bulk_change_table'
 require_relative 'rails/compact_blank'
 require_relative 'rails/content_tag'
 require_relative 'rails/create_table_with_timestamps'
+require_relative 'rails/dangerous_column_names'
 require_relative 'rails/date'
 require_relative 'rails/default_scope'
 require_relative 'rails/delegate'
@@ -87,6 +88,7 @@ require_relative 'rails/presence'
 require_relative 'rails/present'
 require_relative 'rails/rake_environment'
 require_relative 'rails/read_write_attribute'
+require_relative 'rails/redundant_active_record_all_method'
 require_relative 'rails/redundant_allow_nil'
 require_relative 'rails/redundant_foreign_key'
 require_relative 'rails/redundant_presence_validation_on_belongs_to'
@@ -110,6 +112,7 @@ require_relative 'rails/safe_navigation_with_blank'
 require_relative 'rails/save_bang'
 require_relative 'rails/schema_comment'
 require_relative 'rails/scope_args'
+require_relative 'rails/select_map'
 require_relative 'rails/short_i18n'
 require_relative 'rails/skips_model_validations'
 require_relative 'rails/squished_sql_heredocs'
@@ -126,6 +129,7 @@ require_relative 'rails/uniq_before_pluck'
 require_relative 'rails/unique_validation_without_index'
 require_relative 'rails/unknown_env'
 require_relative 'rails/unused_ignored_columns'
+require_relative 'rails/unused_render_content'
 require_relative 'rails/validation'
 require_relative 'rails/where_equals'
 require_relative 'rails/where_exists'

data/lib/rubocop/rails/schema_loader/schema.rb

@@ -83,21 +83,21 @@ module RuboCop
         private
 
         def build_columns(node)
-          each_content(node).map do |child|
+          each_content(node).filter_map do |child|
             next unless child&.send_type?
             next if child.method?(:index)
 
             Column.new(child)
-          end.compact
+          end
         end
 
         def build_indices(node)
-          each_content(node).map do |child|
+          each_content(node).filter_map do |child|
             next unless child&.send_type?
             next unless child.method?(:index)
 
             Index.new(child)
-          end.compact
+          end
         end
 
         def each_content(node, &block)

data/lib/rubocop/rails/schema_loader.rb

@@ -43,7 +43,7 @@ module RuboCop
         return unless path
 
         ast = parse(path, target_ruby_version)
-        Schema.new(ast)
+        Schema.new(ast) if ast
       end
 
       def parse(path, target_ruby_version)

data/lib/rubocop/rails/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Rails
     # This module holds the RuboCop Rails version information.
     module Version
-      STRING = '2.19.1'
+      STRING = '2.21.2'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

data/lib/rubocop-rails.rb

@@ -17,6 +17,14 @@ require_relative 'rubocop/cop/rails_cops'
 
 RuboCop::Cop::Style::HashExcept.minimum_target_ruby_version(2.0)
 
+RuboCop::Cop::Style::InverseMethods.singleton_class.prepend(
+  Module.new do
+    def autocorrect_incompatible_with
+      super.push(RuboCop::Cop::Rails::NegateInclude)
+    end
+  end
+)
+
 RuboCop::Cop::Style::MethodCallWithArgsParentheses.singleton_class.prepend(
   Module.new do
     def autocorrect_incompatible_with