rubocop-rails 2.15.2 → 2.20.2

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies top-level `HashWithIndifferentAccess`.
+      # This has been soft-deprecated since Rails 5.1.
+      #
+      # @example
+      #   # bad
+      #   HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      #   # good
+      #   ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
+      #
+      class TopLevelHashWithIndifferentAccess < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.1
+
+        MSG = 'Avoid top-level `HashWithIndifferentAccess`.'
+
+        # @!method top_level_hash_with_indifferent_access?(node)
+        #   @param [RuboCop::AST::ConstNode] node
+        #   @return [Boolean]
+        def_node_matcher :top_level_hash_with_indifferent_access?, <<~PATTERN
+          (const {nil? cbase} :HashWithIndifferentAccess)
+        PATTERN
+
+        # @param [RuboCop::AST::ConstNode] node
+        def on_const(node)
+          return unless top_level_hash_with_indifferent_access?(node)
+          return if node.parent&.class_type? && node.parent.ancestors.any?(&:module_type?)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.insert_before(node.location.name, 'ActiveSupport::')
+        end
+      end
+    end
+  end
+end

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

@@ -34,6 +34,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,8 +50,6 @@ module RuboCop
       #     # Commit
       #     next if user.active?
       #   end
-      #
-      # @see https://github.com/rails/rails/commit/15aa4200e083
       class TransactionExitStatement < Base
         MSG = <<~MSG.chomp
           Exit statement `%<statement>s` is not allowed. Use `raise` (rollback) or `next` (commit).
@@ -93,7 +96,9 @@ module RuboCop
         end
 
         def nested_block?(statement_node)
-          !statement_node.ancestors.find(&:block_type?).method?(:transaction)
+          block_node = statement_node.ancestors.find(&:block_type?)
+
+          RESTRICT_ON_SEND.none? { |name| block_node.method?(name) }
         end
       end
     end

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

@@ -54,11 +54,9 @@ module RuboCop
         NEWLINE = "\n"
         PATTERN = '[!^block (send (send %<type>s :pluck ...) :uniq ...)]'
 
-        def_node_matcher :conservative_node_match,
-                         format(PATTERN, type: 'const')
+        def_node_matcher :conservative_node_match, format(PATTERN, type: 'const')
 
-        def_node_matcher :aggressive_node_match,
-                         format(PATTERN, type: '_')
+        def_node_matcher :aggressive_node_match, format(PATTERN, type: '_')
 
         def on_send(node)
           uniq = if style == :conservative
@@ -80,8 +78,7 @@ module RuboCop
         private
 
         def dot_method_with_whitespace(method, node)
-          range_between(dot_method_begin_pos(method, node),
-                        node.loc.selector.end_pos)
+          range_between(dot_method_begin_pos(method, node), node.loc.selector.end_pos)
         end
 
         def dot_method_begin_pos(method, node)

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Rails
       # When you define a uniqueness validation in Active Record model,
-      # you also should add a unique index for the column. There are two reasons
+      # you also should add a unique index for the column. There are two reasons.
       # First, duplicated records may occur even if Active Record's validation
       # is defined.
       # Second, it will cause slow queries. The validation executes a `SELECT`
@@ -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
@@ -59,9 +59,7 @@ module RuboCop
           add_indices = schema.add_indices_by(table_name: table_name(klass))
 
           (table.indices + add_indices).any? do |index|
-            index.unique &&
-              (index.columns.to_set == names ||
-               include_column_names_in_expression_index?(index, names))
+            index.unique && (index.columns.to_set == names || include_column_names_in_expression_index?(index, names))
           end
         end
 
@@ -73,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|
@@ -92,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)
@@ -137,15 +134,21 @@ 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])
+          return false unless uniqueness_node.hash_type?
+
+          condition_hash_part?(uniqueness_node, keys: %i[if unless conditions])
+        end
 
+        def condition_hash_part?(pairs, keys:)
           pairs.each_pair.any? do |pair|
             key = pair.key
             next unless key.sym_type?
 
-            key.value == :if || key.value == :unless
+            keys.include?(key.value)
           end
         end
 

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

@@ -19,8 +19,7 @@ module RuboCop
       #   Rails.env == 'production'
       class UnknownEnv < Base
         MSG = 'Unknown environment `%<name>s`.'
-        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
-                      'Did you mean `%<similar>s`?'
+        MSG_SIMILAR = 'Unknown environment `%<name>s`. Did you mean `%<similar>s`?'
 
         def_node_matcher :rails_env?, <<~PATTERN
           (send
@@ -79,8 +78,7 @@ module RuboCop
 
         def unknown_env_predicate?(name)
           name = name.to_s
-          name.end_with?('?') &&
-            !environments.include?(name[0..-2])
+          name.end_with?('?') && !environments.include?(name[0..-2])
         end
 
         def unknown_env_name?(name)

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

@@ -28,12 +28,16 @@ module RuboCop
           (send self :ignored_columns= $array)
         PATTERN
 
+        def_node_matcher :appended_ignored_columns, <<~PATTERN
+          (op-asgn (send self :ignored_columns) :+ $array)
+        PATTERN
+
         def_node_matcher :column_name, <<~PATTERN
           ({str sym} $_)
         PATTERN
 
         def on_send(node)
-          return unless (columns = ignored_columns(node))
+          return unless (columns = ignored_columns(node) || appended_ignored_columns(node))
           return unless schema
 
           table = table(node)
@@ -43,6 +47,7 @@ module RuboCop
             check_column_existence(column_node, table)
           end
         end
+        alias on_op_asgn on_send
 
         private
 

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

@@ -35,8 +35,7 @@ module RuboCop
       class Validation < Base
         extend AutoCorrector
 
-        MSG = 'Prefer the new style validations `%<prefer>s` over ' \
-              '`%<current>s`.'
+        MSG = 'Prefer the new style validations `%<prefer>s` over `%<current>s`.'
 
         TYPES = %w[
           acceptance
@@ -62,8 +61,7 @@ module RuboCop
 
           add_offense(range, message: message(node)) do |corrector|
             last_argument = node.arguments.last
-            return if !last_argument.literal? && !last_argument.splat_type? &&
-                      !frozen_array_argument?(last_argument)
+            return if !last_argument.literal? && !last_argument.splat_type? && !frozen_array_argument?(last_argument)
 
             corrector.replace(range, 'validates')
             correct_validate_type(corrector, node)
@@ -104,10 +102,7 @@ module RuboCop
         end
 
         def correct_validate_type_for_hash(corrector, node, arguments)
-          corrector.replace(
-            arguments.loc.expression,
-            "#{validate_type(node)}: #{braced_options(arguments)}"
-          )
+          corrector.replace(arguments, "#{validate_type(node)}: #{braced_options(arguments)}")
         end
 
         def correct_validate_type_for_array(corrector, node, arguments, loc)
@@ -121,10 +116,7 @@ module RuboCop
                           end
           end
 
-          corrector.replace(
-            loc.expression,
-            "#{attributes.join(', ')}, #{validate_type(node)}: true"
-          )
+          corrector.replace(loc.expression, "#{attributes.join(', ')}, #{validate_type(node)}: true")
         end
 
         def validate_type(node)

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

@@ -65,7 +65,7 @@ module RuboCop
         private
 
         def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def extract_column_and_value(template_node, value_node)

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

@@ -105,7 +105,7 @@ module RuboCop
           if exists_style?
             node.receiver.loc.selector.join(node.loc.selector)
           elsif where_style?
-            node.loc.selector.with(end_pos: node.loc.expression.end_pos)
+            node.loc.selector.with(end_pos: node.source_range.end_pos)
           end
         end
 

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Use `where.missing(...)` to find missing relationship records.
+      #
+      # This cop is enabled in Rails 6.1 or higher.
+      #
+      # @example
+      #   # bad
+      #   Post.left_joins(:author).where(authors: { id: nil })
+      #
+      #   # good
+      #   Post.where.missing(:author)
+      #
+      class WhereMissing < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `where.missing(:%<left_joins_association>s)` instead of ' \
+              '`%<left_joins_method>s(:%<left_joins_association>s).where(%<where_association>s: { id: nil })`.'
+        RESTRICT_ON_SEND = %i[left_joins left_outer_joins].freeze
+
+        minimum_target_rails_version 6.1
+
+        # @!method where_node_and_argument(node)
+        def_node_search :where_node_and_argument, <<~PATTERN
+          $(send ... :where (hash <(pair $(sym _) (hash (pair (sym :id) (nil))))...> ))
+        PATTERN
+
+        # @!method missing_relationship(node)
+        def_node_search :missing_relationship, <<~PATTERN
+          (pair (sym _) (hash (pair (sym :id) (nil))))
+        PATTERN
+
+        def on_send(node)
+          return unless node.first_argument.sym_type?
+
+          root_receiver = root_receiver(node)
+          where_node_and_argument(root_receiver) do |where_node, where_argument|
+            next unless root_receiver == root_receiver(where_node)
+            next unless same_relationship?(where_argument, node.first_argument)
+
+            range = range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+            register_offense(node, where_node, where_argument, range)
+            break
+          end
+        end
+
+        private
+
+        def root_receiver(node)
+          parent = node.parent
+          if !parent&.send_type? || parent.method?(:or) || parent.method?(:and)
+            node
+          else
+            root_receiver(parent)
+          end
+        end
+
+        def same_relationship?(where, left_joins)
+          where.value.to_s.match?(/^#{left_joins.value}s?$/)
+        end
+
+        def register_offense(node, where_node, where_argument, range)
+          add_offense(range, message: message(node, where_argument)) do |corrector|
+            corrector.replace(node.loc.selector, 'where.missing')
+            if multi_condition?(where_node.first_argument)
+              replace_where_method(corrector, where_node)
+            else
+              remove_where_method(corrector, node, where_node)
+            end
+          end
+        end
+
+        def replace_where_method(corrector, where_node)
+          missing_relationship(where_node) do |where_clause|
+            corrector.remove(replace_range(where_clause))
+          end
+        end
+
+        def replace_range(child)
+          if (right_sibling = child.right_sibling)
+            range_between(child.source_range.begin_pos, right_sibling.source_range.begin_pos)
+          else
+            range_between(child.left_sibling.source_range.end_pos, child.source_range.end_pos)
+          end
+        end
+
+        def remove_where_method(corrector, node, where_node)
+          range = range_between(where_node.loc.selector.begin_pos, where_node.loc.end.end_pos)
+          if node.multiline? && !same_line?(node, where_node)
+            range = range_by_whole_lines(range, include_final_newline: true)
+          else
+            corrector.remove(where_node.loc.dot)
+          end
+
+          corrector.remove(range)
+        end
+
+        def same_line?(left_joins_node, where_node)
+          left_joins_node.loc.selector.line == where_node.loc.selector.line
+        end
+
+        def multi_condition?(where_arg)
+          where_arg.children.count > 1
+        end
+
+        def message(node, where_argument)
+          format(MSG, left_joins_association: node.first_argument.value, left_joins_method: node.method_name,
+                      where_association: where_argument.value)
+        end
+      end
+    end
+  end
+end

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

@@ -64,7 +64,7 @@ module RuboCop
         private
 
         def offense_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def extract_column_and_value(template_node, value_node)

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies calls to `where.not` with multiple hash arguments.
+      #
+      # The behavior of `where.not` changed in Rails 6.1. Prior to the change,
+      # `.where.not(trashed: true, role: 'admin')` evaluated to
+      # `WHERE trashed != TRUE AND role != 'admin'`.
+      # From Rails 6.1 onwards, this executes the query
+      # `WHERE NOT (trashed == TRUE AND roles == 'admin')`.
+      #
+      # @example
+      #   # bad
+      #   User.where.not(trashed: true, role: 'admin')
+      #   User.where.not(trashed: true, role: ['moderator', 'admin'])
+      #   User.joins(:posts).where.not(posts: { trashed: true, title: 'Rails' })
+      #
+      #   # good
+      #   User.where.not(trashed: true)
+      #   User.where.not(role: ['moderator', 'admin'])
+      #   User.where.not(trashed: true).where.not(role: ['moderator', 'admin'])
+      #   User.where.not('trashed = ? OR role = ?', true, 'admin')
+      class WhereNotWithMultipleConditions < Base
+        MSG = 'Use a SQL statement instead of `where.not` with multiple conditions.'
+        RESTRICT_ON_SEND = %i[not].freeze
+
+        def_node_matcher :where_not_call?, <<~PATTERN
+          (send (send _ :where) :not $...)
+        PATTERN
+
+        def on_send(node)
+          where_not_call?(node) do |args|
+            next unless args[0]&.hash_type?
+            next unless multiple_arguments_hash? args[0]
+
+            range = node.receiver.loc.selector.with(end_pos: node.source_range.end_pos)
+
+            add_offense(range)
+          end
+        end
+
+        private
+
+        def multiple_arguments_hash?(hash)
+          return true if hash.pairs.size >= 2
+          return false unless hash.values[0]&.hash_type?
+
+          multiple_arguments_hash?(hash.values[0])
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -8,12 +8,15 @@ require_relative 'mixin/index_method'
 require_relative 'mixin/migrations_helper'
 require_relative 'mixin/target_rails_version'
 
+require_relative 'rails/action_controller_flash_before_render'
 require_relative 'rails/action_controller_test_case'
 require_relative 'rails/action_filter'
+require_relative 'rails/action_order'
 require_relative 'rails/active_record_aliases'
 require_relative 'rails/active_record_callbacks_order'
 require_relative 'rails/active_record_override'
 require_relative 'rails/active_support_aliases'
+require_relative 'rails/active_support_on_load'
 require_relative 'rails/add_column_index'
 require_relative 'rails/after_commit_override'
 require_relative 'rails/application_controller'
@@ -50,6 +53,7 @@ require_relative 'rails/file_path'
 require_relative 'rails/find_by'
 require_relative 'rails/find_by_id'
 require_relative 'rails/find_each'
+require_relative 'rails/freeze_time'
 require_relative 'rails/has_and_belongs_to_many'
 require_relative 'rails/has_many_or_has_one_dependent'
 require_relative 'rails/helper_instance_variable'
@@ -58,6 +62,7 @@ require_relative 'rails/http_status'
 require_relative 'rails/i18n_lazy_lookup'
 require_relative 'rails/i18n_locale_assignment'
 require_relative 'rails/i18n_locale_texts'
+require_relative 'rails/ignored_columns_assignment'
 require_relative 'rails/ignored_skip_action_filter_option'
 require_relative 'rails/index_by'
 require_relative 'rails/index_with'
@@ -94,9 +99,11 @@ require_relative 'rails/render_inline'
 require_relative 'rails/render_plain_text'
 require_relative 'rails/request_referer'
 require_relative 'rails/require_dependency'
+require_relative 'rails/response_parsed_body'
 require_relative 'rails/reversible_migration'
 require_relative 'rails/reversible_migration_method_definition'
 require_relative 'rails/root_join_chain'
+require_relative 'rails/root_pathname_methods'
 require_relative 'rails/root_public_path'
 require_relative 'rails/safe_navigation'
 require_relative 'rails/safe_navigation_with_blank'
@@ -108,9 +115,12 @@ require_relative 'rails/skips_model_validations'
 require_relative 'rails/squished_sql_heredocs'
 require_relative 'rails/strip_heredoc'
 require_relative 'rails/table_name_assignment'
+require_relative 'rails/three_state_boolean_column'
 require_relative 'rails/time_zone'
 require_relative 'rails/time_zone_assignment'
 require_relative 'rails/to_formatted_s'
+require_relative 'rails/to_s_with_argument'
+require_relative 'rails/top_level_hash_with_indifferent_access'
 require_relative 'rails/transaction_exit_statement'
 require_relative 'rails/uniq_before_pluck'
 require_relative 'rails/unique_validation_without_index'
@@ -119,4 +129,6 @@ require_relative 'rails/unused_ignored_columns'
 require_relative 'rails/validation'
 require_relative 'rails/where_equals'
 require_relative 'rails/where_exists'
+require_relative 'rails/where_missing'
 require_relative 'rails/where_not'
+require_relative 'rails/where_not_with_multiple_conditions'

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/version.rb

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

data/lib/rubocop/rails.rb

@@ -5,7 +5,7 @@ module RuboCop
   module Rails
     PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
     CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
-    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read, permitted_classes: [Regexp, Symbol]).freeze
 
     private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
 

data/lib/rubocop-rails.rb

@@ -3,6 +3,7 @@
 require 'rubocop'
 require 'rack/utils'
 require 'active_support/inflector'
+require 'active_support/core_ext/object/blank'
 
 require_relative 'rubocop/rails'
 require_relative 'rubocop/rails/version'
@@ -14,6 +15,16 @@ RuboCop::Rails::Inject.defaults!
 
 require_relative 'rubocop/cop/rails_cops'
 
+RuboCop::Cop::Style::HashExcept.minimum_target_ruby_version(2.0)
+
+RuboCop::Cop::Style::MethodCallWithArgsParentheses.singleton_class.prepend(
+  Module.new do
+    def autocorrect_incompatible_with
+      super.push(RuboCop::Cop::Rails::EagerEvaluationLogMessage)
+    end
+  end
+)
+
 RuboCop::Cop::Style::RedundantSelf.singleton_class.prepend(
   Module.new do
     def autocorrect_incompatible_with