rubocop-rails 2.15.2 → 2.17.3

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

@@ -37,7 +37,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[has_many has_one].freeze
 
         def_node_search :active_resource_class?, <<~PATTERN
-          (const (const nil? :ActiveResource) :Base)
+          (const (const {nil? cbase} :ActiveResource) :Base)
         PATTERN
 
         def_node_matcher :association_without_options?, <<~PATTERN
@@ -105,9 +105,7 @@ module RuboCop
 
             return false unless node.parent
 
-            return true if contain_valid_options_in_with_options_block?(
-              node.parent.parent
-            )
+            return true if contain_valid_options_in_with_options_block?(node.parent.parent)
           end
 
           false

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

@@ -37,7 +37,7 @@ module RuboCop
         def_node_matcher :form_builder_class?, <<~PATTERN
           (const
             (const
-               (const nil? :ActionView) :Helpers) :FormBuilder)
+               (const {nil? cbase} :ActionView) :Helpers) :FormBuilder)
         PATTERN
 
         def on_ivar(node)

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

@@ -22,11 +22,8 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%<verb>s`.'
-        KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env to
-        ].freeze
+        MSG = 'Use keyword arguments instead of positional arguments for http call: `%<verb>s`.'
+        KEYWORD_ARGS = %i[method params session body flash xhr as headers env to].freeze
         ROUTING_METHODS = %i[draw routes].freeze
         RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
 
@@ -75,8 +72,7 @@ module RuboCop
           return false if kwsplat_hash?(data)
 
           data.each_pair.none? do |pair|
-            special_keyword_arg?(pair.key) ||
-              (format_arg?(pair.key) && data.pairs.one?)
+            special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
           end
         end
 
@@ -98,8 +94,7 @@ module RuboCop
           return '' if data.hash_type? && data.empty?
 
           hash_data = if data.hash_type?
-                        format('{ %<data>s }',
-                               data: data.pairs.map(&:source).join(', '))
+                        format('{ %<data>s }', data: data.pairs.map(&:source).join(', '))
                       else
                         # user supplies an object,
                         # no need to surround with braces

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

@@ -84,10 +84,8 @@ module RuboCop
 
         # :nodoc:
         class SymbolicStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` to define HTTP status code.'
 
           attr_reader :node
 
@@ -118,17 +116,14 @@ module RuboCop
           end
 
           def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
+            node.int_type? && !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
           end
         end
 
         # :nodoc:
         class NumericStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` to define HTTP status code.'
           PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node

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

@@ -34,6 +34,8 @@ module RuboCop
 
         MSG = 'Use "lazy" lookup for the text used in controllers.'
 
+        RESTRICT_ON_SEND = %i[translate t].freeze
+
         def_node_matcher :translate_call?, <<~PATTERN
           (send nil? {:translate :t} ${sym_type? str_type?} ...)
         PATTERN

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for assignments of `ignored_columns` that may override previous
+      # assignments.
+      #
+      # Overwriting previous assignments is usually a mistake, since it will
+      # un-ignore the first set of columns. Since duplicate column names is not
+      # a problem, it is better to simply append to the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one]
+      #   end
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one]
+      #     self.ignored_columns += [:two]
+      #   end
+      #
+      class IgnoredColumnsAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Use `+=` instead of `=`.'
+        RESTRICT_ON_SEND = %i[ignored_columns=].freeze
+
+        def on_send(node)
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '+=')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -42,12 +42,7 @@ module RuboCop
           `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
         MSG
 
-        RESTRICT_ON_SEND = %i[
-          skip_after_action
-          skip_around_action
-          skip_before_action
-          skip_action_callback
-        ].freeze
+        RESTRICT_ON_SEND = %i[skip_after_action skip_around_action skip_before_action skip_action_callback].freeze
 
         FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
 
@@ -67,11 +62,9 @@ module RuboCop
           options = options_hash(options)
 
           if if_and_only?(options)
-            add_offense(options[:if],
-                        message: format(MSG, prefer: :only, ignore: :if))
+            add_offense(options[:if], message: format(MSG, prefer: :only, ignore: :if))
           elsif if_and_except?(options)
-            add_offense(options[:except],
-                        message: format(MSG, prefer: :if, ignore: :except))
+            add_offense(options[:except], message: format(MSG, prefer: :if, ignore: :except))
           end
         end
 

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

@@ -46,7 +46,7 @@ module RuboCop
 
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
-            (const _ :Hash)
+            (const {nil? cbase} :Hash)
             :[]
             (block
               (call _ {:map :collect})

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

@@ -49,7 +49,7 @@ module RuboCop
 
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
-            (const _ :Hash)
+            (const {nil? cbase} :Hash)
             :[]
             (block
               (call _ {:map :collect})

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

@@ -192,8 +192,7 @@ module RuboCop
           end
           return if options_ignoring_inverse_of?(options)
 
-          return unless scope?(arguments) ||
-                        options_requiring_inverse_of?(options)
+          return unless scope?(arguments) || options_requiring_inverse_of?(options)
 
           return if options_contain_inverse_of?(options)
 
@@ -206,8 +205,7 @@ module RuboCop
 
         def options_requiring_inverse_of?(options)
           required = options.any? do |opt|
-            conditions_option?(opt) ||
-              foreign_key_option?(opt)
+            conditions_option?(opt) || foreign_key_option?(opt)
           end
 
           return required if target_rails_version >= 5.2
@@ -227,8 +225,7 @@ module RuboCop
 
         def with_options_arguments(recv, node)
           blocks = node.each_ancestor(:block).select do |block|
-            block.send_node.command?(:with_options) &&
-              same_context_in_with_options?(block.arguments.first, recv)
+            block.send_node.command?(:with_options) && same_context_in_with_options?(block.arguments.first, recv)
           end
           blocks.flat_map { |n| n.send_node.arguments }
         end

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

@@ -184,13 +184,9 @@ module RuboCop
         # @return [String]
         def message(methods, parent)
           if methods.size == 1
-            format(MSG,
-                   action: "`#{methods[0]}` is",
-                   type: parent.type)
+            format(MSG, action: "`#{methods[0]}` is", type: parent.type)
           else
-            format(MSG,
-                   action: "`#{methods.join('`, `')}` are",
-                   type: parent.type)
+            format(MSG, action: "`#{methods.join('`, `')}` are", type: parent.type)
           end
         end
       end

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

@@ -68,10 +68,7 @@ module RuboCop
 
         def append_to_rel(rel_node, corrector)
           existing_rel = rel_node.children.last.value
-          str_range = rel_node.children.last.loc.expression.adjust(
-            begin_pos: 1,
-            end_pos: -1
-          )
+          str_range = rel_node.children.last.loc.expression.adjust(begin_pos: 1, end_pos: -1)
           corrector.replace(str_range, "#{existing_rel} noopener")
         end
 

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

@@ -34,8 +34,8 @@ module RuboCop
 
         def_node_matcher :mailer_base_class?, <<~PATTERN
           {
-            (const (const nil? :ActionMailer) :Base)
-            (const nil? :ApplicationMailer)
+            (const (const {nil? cbase} :ActionMailer) :Base)
+            (const {nil? cbase} :ApplicationMailer)
           }
         PATTERN
 
@@ -44,7 +44,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_new_definition?, <<~PATTERN
-          (send (const nil? :Class) :new #mailer_base_class?)
+          (send (const {nil? cbase} :Class) :new #mailer_base_class?)
         PATTERN
 
         def on_class(node)

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

@@ -29,7 +29,7 @@ module RuboCop
 
           basename = basename_without_timestamp_and_suffix(processed_source.file_path)
 
-          class_identifier = node.identifier
+          class_identifier = node.identifier.location.name
           camelized_basename = camelize(basename)
           return if class_identifier.source.casecmp(camelized_basename).zero?
 

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

@@ -21,11 +21,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not write to stdout. ' \
-              "Use Rails's logger if you want to log."
-        RESTRICT_ON_SEND = %i[
-          ap p pp pretty_print print puts binwrite syswrite write write_nonblock
-        ].freeze
+        MSG = "Do not write to stdout. Use Rails's logger if you want to log."
+        RESTRICT_ON_SEND = %i[ap p pp pretty_print print puts binwrite syswrite write write_nonblock].freeze
 
         def_node_matcher :output?, <<~PATTERN
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
@@ -35,7 +32,7 @@ module RuboCop
           (send
             {
               (gvar #match_gvar?)
-              {(const nil? :STDOUT) (const nil? :STDERR)}
+              (const {nil? cbase} {:STDOUT :STDERR})
             }
             {:binwrite :syswrite :write :write_nonblock}
             ...)

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

@@ -21,42 +21,62 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Prefer `pluck(:%<value>s)` over `%<current>s`.'
+        MSG = 'Prefer `%<replacement>s` over `%<current>s`.'
 
         minimum_target_rails_version 5.0
 
         def_node_matcher :pluck_candidate?, <<~PATTERN
-          ({block numblock} (send _ {:map :collect}) $_argument (send (lvar $_element) :[] (sym $_value)))
+          ({block numblock} (send _ {:map :collect}) $_argument (send lvar :[] $_key))
         PATTERN
 
         def on_block(node)
-          pluck_candidate?(node) do |argument, element, value|
+          pluck_candidate?(node) do |argument, key|
+            next unless use_one_block_argument?(argument)
+
             match = if node.block_type?
-                      argument.children.first.source.to_sym == element
+                      block_argument = argument.children.first.source
+                      use_block_argument_in_key?(block_argument, key)
                     else # numblock
-                      argument == 1 && element == :_1
+                      argument == 1 && use_block_argument_in_key?('_1', key)
                     end
             next unless match
 
-            message = message(value, node)
-
-            add_offense(offense_range(node), message: message) do |corrector|
-              corrector.replace(offense_range(node), "pluck(:#{value})")
-            end
+            register_offense(node, key)
           end
         end
         alias on_numblock on_block
 
         private
 
+        def use_one_block_argument?(argument)
+          return true if argument == 1 # Checks for numbered argument `_1`.
+
+          argument.respond_to?(:one?) && argument.one?
+        end
+
+        def use_block_argument_in_key?(block_argument, key)
+          return false if block_argument == key.source
+
+          key.each_descendant(:lvar).none? { |lvar| block_argument == lvar.source }
+        end
+
         def offense_range(node)
           node.send_node.loc.selector.join(node.loc.end)
         end
 
-        def message(value, node)
+        def register_offense(node, key)
+          replacement = "pluck(#{key.source})"
+          message = message(replacement, node)
+
+          add_offense(offense_range(node), message: message) do |corrector|
+            corrector.replace(offense_range(node), replacement)
+          end
+        end
+
+        def message(replacement, node)
           current = offense_range(node).source
 
-          format(MSG, value: value, current: current)
+          format(MSG, replacement: replacement, current: current)
         end
       end
     end

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

@@ -94,8 +94,7 @@ module RuboCop
         end
 
         def duration_method?(method_name)
-          SINGULAR_DURATION_METHODS.key?(method_name) ||
-            PLURAL_DURATION_METHODS.key?(method_name)
+          SINGULAR_DURATION_METHODS.key?(method_name) || PLURAL_DURATION_METHODS.key?(method_name)
         end
       end
     end

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

@@ -93,7 +93,7 @@ module RuboCop
 
         def register_offense(node, receiver, other)
           add_offense(node, message: message(node, receiver, other)) do |corrector|
-            corrector.replace(node.source_range, replacement(receiver, other))
+            corrector.replace(node.source_range, replacement(receiver, other, node.left_sibling))
           end
         end
 
@@ -106,12 +106,20 @@ module RuboCop
         end
 
         def message(node, receiver, other)
-          format(MSG,
-                 prefer: replacement(receiver, other),
-                 current: node.source)
+          prefer = replacement(receiver, other, node.left_sibling).gsub(/^\s*|\n/, '')
+          current = current(node).gsub(/^\s*|\n/, '')
+          format(MSG, prefer: prefer, current: current)
         end
 
-        def replacement(receiver, other)
+        def current(node)
+          if node.source.include?("\n")
+            "#{node.loc.keyword.with(end_pos: node.condition.loc.selector.end_pos).source} ... end"
+          else
+            node.source
+          end
+        end
+
+        def replacement(receiver, other, left_sibling)
           or_source = if other&.send_type?
                         build_source_for_or_method(other)
                       elsif other.nil? || other.nil_type?
@@ -120,23 +128,24 @@ module RuboCop
                         " || #{other.source}"
                       end
 
-          "#{receiver.source}.presence" + or_source
+          replaced = "#{receiver.source}.presence#{or_source}"
+          left_sibling ? "(#{replaced})" : replaced
         end
 
         def build_source_for_or_method(other)
-          if other.parenthesized? || other.method?('[]') || !other.arguments?
+          if other.parenthesized? || other.method?('[]') || other.arithmetic_operation? || !other.arguments?
             " || #{other.source}"
           else
-            method = range_between(
-              other.source_range.begin_pos,
-              other.first_argument.source_range.begin_pos - 1
-            ).source
-
+            method = method_range(other).source
             arguments = other.arguments.map(&:source).join(', ')
 
             " || #{method}(#{arguments})"
           end
         end
+
+        def method_range(node)
+          range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos - 1)
+        end
       end
     end
   end

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

@@ -47,10 +47,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
-                                   '`%<current>s`.'
-        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
-                           '`%<current>s`.'
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :exists_and_not_empty?, <<~PATTERN
@@ -118,8 +116,7 @@ module RuboCop
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)
-            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
-                                           current: range.source)
+            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver), current: range.source)
             add_offense(range, message: msg) do |corrector|
               autocorrect(corrector, node)
             end

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

@@ -39,7 +39,7 @@ module RuboCop
           (block $(send nil? :task ...) ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           task_definition?(node) do |task_method|
             return if task_name(task_method) == :default
             return if with_dependencies?(task_method)

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

@@ -30,11 +30,9 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_SAME =
-          '`allow_nil` is redundant when `allow_blank` has the same value.'
+        MSG_SAME = '`allow_nil` is redundant when `allow_blank` has the same value.'
 
-        MSG_ALLOW_NIL_FALSE =
-          '`allow_nil: false` is redundant when `allow_blank` is true.'
+        MSG_ALLOW_NIL_FALSE = '`allow_nil: false` is redundant when `allow_blank` is true.'
 
         RESTRICT_ON_SEND = %i[validates].freeze
 

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

@@ -41,7 +41,7 @@ module RuboCop
           association_with_foreign_key(node) do |type, name, options, foreign_key_pair, foreign_key|
             if redundant?(node, type, name, options, foreign_key)
               add_offense(foreign_key_pair.loc.expression) do |corrector|
-                range = range_with_surrounding_space(range: foreign_key_pair.source_range, side: :left)
+                range = range_with_surrounding_space(foreign_key_pair.source_range, side: :left)
                 range = range_with_surrounding_comma(range, :left)
 
                 corrector.remove(range)

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

@@ -143,7 +143,7 @@ module RuboCop
         def_node_matcher :belongs_to_without_fk?, <<~PATTERN
           {
             (send nil? :belongs_to (sym %1))        # belongs_to :user
-            (send nil? :belongs_to (sym %1) !hash)  # belongs_to :user, -> { not_deleted }
+            (send nil? :belongs_to (sym %1) !hash ...)  # belongs_to :user, -> { not_deleted }
             (send nil? :belongs_to (sym %1) !(hash <(pair (sym :foreign_key) _) ...>))
           }
         PATTERN
@@ -217,7 +217,7 @@ module RuboCop
           keys.each do |key|
             key_node = node.arguments.find { |arg| arg.value == key }
             key_range = range_with_surrounding_space(
-              range: range_with_surrounding_comma(key_node.source_range, :right),
+              range_with_surrounding_comma(key_node.source_range, :right),
               side: :right
             )
             corrector.remove(key_range)
@@ -226,7 +226,7 @@ module RuboCop
 
         def remove_presence_option(corrector, presence)
           range = range_with_surrounding_comma(
-            range_with_surrounding_space(range: presence.source_range, side: :left),
+            range_with_surrounding_space(presence.source_range, side: :left),
             :left
           )
           corrector.remove(range)

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

@@ -60,15 +60,6 @@ module RuboCop
 
         MSG = 'Redundant receiver in `with_options`.'
 
-        def_node_matcher :with_options?, <<~PATTERN
-          (block
-            (send nil? :with_options
-              (...))
-            (args
-              $_arg)
-            $_body)
-        PATTERN
-
         def_node_search :all_block_nodes_in, <<~PATTERN
           (block ...)
         PATTERN
@@ -78,29 +69,42 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          with_options?(node) do |arg, body|
-            return if body.nil?
-            return unless all_block_nodes_in(body).count.zero?
-
-            send_nodes = all_send_nodes_in(body)
-
-            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
-              send_nodes.each do |send_node|
-                receiver = send_node.receiver
-                add_offense(receiver.source_range) do |corrector|
-                  autocorrect(corrector, send_node)
-                end
-              end
+          return unless node.method?(:with_options)
+          return unless (body = node.body)
+          return unless all_block_nodes_in(body).count.zero?
+
+          send_nodes = all_send_nodes_in(body)
+          return unless redundant_receiver?(send_nodes, node)
+
+          send_nodes.each do |send_node|
+            receiver = send_node.receiver
+            add_offense(receiver.source_range) do |corrector|
+              autocorrect(corrector, send_node, node)
             end
           end
         end
 
+        alias on_numblock on_block
+
         private
 
-        def autocorrect(corrector, node)
-          corrector.remove(node.receiver.source_range)
-          corrector.remove(node.loc.dot)
-          corrector.remove(block_argument_range(node))
+        def autocorrect(corrector, send_node, node)
+          corrector.remove(send_node.receiver.source_range)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(block_argument_range(send_node)) unless node.numblock_type?
+        end
+
+        def redundant_receiver?(send_nodes, node)
+          proc = if node.numblock_type?
+                   ->(n) { n.receiver.lvar_type? && n.receiver.source == '_1' }
+                 else
+                   return false if node.arguments.empty?
+
+                   arg = node.arguments.first
+                   ->(n) { same_value?(arg, n.receiver) }
+                 end
+
+          send_nodes.all?(&proc)
         end
 
         def block_argument_range(node)