rubocop-rails 2.20.2 → 2.24.1

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

@@ -163,9 +163,9 @@ module RuboCop
 
         def autocorrect_extension_after_rails_root_join_in_dstr(corrector, node, rails_root_index, extension_node)
           rails_root_node = node.children[rails_root_index].children.first
-          return unless rails_root_node.arguments.last.str_type?
+          return unless rails_root_node.last_argument.str_type?
 
-          corrector.insert_before(rails_root_node.arguments.last.location.end, extension_node.source)
+          corrector.insert_before(rails_root_node.last_argument.location.end, extension_node.source)
           corrector.remove(extension_node)
         end
 
@@ -174,17 +174,20 @@ module RuboCop
           corrector.remove(
             range_with_surrounding_space(
               range_with_surrounding_comma(
-                node.arguments.first.source_range,
+                node.first_argument.source_range,
                 :right
               ),
               side: :right
             )
           )
+          node.arguments.filter(&:str_type?).each do |argument|
+            corrector.replace(argument, argument.value.delete_prefix('/').inspect)
+          end
           corrector.insert_after(node, '.to_s')
         end
 
         def autocorrect_rails_root_join_with_string_arguments(corrector, node)
-          corrector.replace(node.arguments.first, %("#{node.arguments.map(&:value).join('/')}"))
+          corrector.replace(node.first_argument, %("#{node.arguments.map(&:value).join('/')}"))
           node.arguments[1..].each do |argument|
             corrector.remove(
               range_with_surrounding_comma(
@@ -218,7 +221,7 @@ module RuboCop
         end
 
         def append_argument(corrector, node, argument_source)
-          corrector.insert_after(node.arguments.last, %(, "#{argument_source}"))
+          corrector.insert_after(node.last_argument, %(, "#{argument_source}"))
         end
 
         def replace_with_rails_root_join(corrector, node, argument_source)
@@ -230,7 +233,7 @@ module RuboCop
         end
 
         def extension_node?(node)
-          node&.str_type? && node.source.start_with?('.')
+          node&.str_type? && node.source.match?(/\A\.[A-Za-z]+/)
         end
       end
     end

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

@@ -28,7 +28,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `find_by` instead of `where.%<method>s`.'
+        MSG = 'Use `find_by` instead of `where%<dot>s%<method>s`.'
         RESTRICT_ON_SEND = %i[first take].freeze
 
         def on_send(node)
@@ -37,7 +37,7 @@ module RuboCop
 
           range = offense_range(node)
 
-          add_offense(range, message: format(MSG, method: node.method_name)) do |corrector|
+          add_offense(range, message: format(MSG, dot: node.loc.dot.source, method: node.method_name)) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -59,7 +59,7 @@ module RuboCop
           return if node.method?(:first)
 
           where_loc = node.receiver.loc.selector
-          first_loc = range_between(node.loc.dot.begin_pos, node.loc.selector.end_pos)
+          first_loc = range_between(node.receiver.source_range.end_pos, node.loc.selector.end_pos)
 
           corrector.replace(where_loc, 'find_by')
           corrector.replace(first_loc, '')

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

@@ -24,40 +24,39 @@ module RuboCop
         RESTRICT_ON_SEND = %i[take! find_by_id! find_by!].freeze
 
         def_node_matcher :where_take?, <<~PATTERN
-          (send
-            $(send _ :where
+          (call
+            $(call _ :where
               (hash
                 (pair (sym :id) $_))) :take!)
         PATTERN
 
         def_node_matcher :find_by?, <<~PATTERN
           {
-            (send _ :find_by_id! $_)
-            (send _ :find_by! (hash (pair (sym :id) $_)))
+            (call _ :find_by_id! $_)
+            (call _ :find_by! (hash (pair (sym :id) $_)))
           }
         PATTERN
 
         def on_send(node)
           where_take?(node) do |where, id_value|
             range = where_take_offense_range(node, where)
-            bad_method = build_where_take_bad_method(id_value)
 
-            register_offense(range, id_value, bad_method)
+            register_offense(range, id_value)
           end
 
           find_by?(node) do |id_value|
             range = find_by_offense_range(node)
-            bad_method = build_find_by_bad_method(node, id_value)
 
-            register_offense(range, id_value, bad_method)
+            register_offense(range, id_value)
           end
         end
+        alias on_csend on_send
 
         private
 
-        def register_offense(range, id_value, bad_method)
+        def register_offense(range, id_value)
           good_method = build_good_method(id_value)
-          message = format(MSG, good_method: good_method, bad_method: bad_method)
+          message = format(MSG, good_method: good_method, bad_method: range.source)
 
           add_offense(range, message: message) do |corrector|
             corrector.replace(range, good_method)
@@ -75,19 +74,6 @@ module RuboCop
         def build_good_method(id_value)
           "find(#{id_value.source})"
         end
-
-        def build_where_take_bad_method(id_value)
-          "where(id: #{id_value.source}).take!"
-        end
-
-        def build_find_by_bad_method(node, id_value)
-          case node.method_name
-          when :find_by_id!
-            "find_by_id!(#{id_value.source})"
-          when :find_by!
-            "find_by!(id: #{id_value.source})"
-          end
-        end
       end
     end
   end

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

@@ -69,7 +69,7 @@ module RuboCop
           return false unless CONVERT_METHODS.include?(method_name)
 
           child_node, child_method_name, time_argument = *node.children
-          return if time_argument
+          return false if time_argument
 
           current_time?(child_node, child_method_name)
         end

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

@@ -60,7 +60,7 @@ module RuboCop
           (block
             (send nil? :with_options
               (hash $...))
-            (args) ...)
+            (args _?) ...)
         PATTERN
 
         def_node_matcher :association_extension_block?, <<~PATTERN

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for use of the helper methods which reference
       # instance variables.
       #
-      # Relying on instance variables makes it difficult to re-use helper
+      # Relying on instance variables makes it difficult to reuse helper
       # methods.
       #
       # If it seems awkward to explicitly pass in each dependent

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

@@ -8,6 +8,7 @@ module RuboCop
       # @example EnforcedStyle: symbolic (default)
       #   # bad
       #   render :foo, status: 200
+      #   render :foo, status: '200'
       #   render json: { foo: 'bar' }, status: 200
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
@@ -50,7 +51,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :status_code, <<~PATTERN
-          (hash <(pair (sym :status) ${int sym}) ...>)
+          (hash <(pair (sym :status) ${int sym str}) ...>)
         PATTERN
 
         def on_send(node)
@@ -108,7 +109,7 @@ module RuboCop
           private
 
           def symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number.to_i)
           end
 
           def number
@@ -133,7 +134,7 @@ module RuboCop
           end
 
           def offensive?
-            !node.int_type? && !permitted_symbol?
+            !node.int_type? && !permitted_symbol? && number
           end
 
           def message

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

@@ -5,7 +5,13 @@ module RuboCop
     module Rails
       # Checks for places where I18n "lazy" lookup can be used.
       #
-      # @example
+      # This cop has two different enforcement modes. When the EnforcedStyle
+      # is `lazy` (the default), explicit lookups are added as offenses.
+      #
+      # When the EnforcedStyle is `explicit` then lazy lookups are added as
+      # offenses.
+      #
+      # @example EnforcedStyle: lazy (default)
       #   # en.yml
       #   # en:
       #   #   books:
@@ -28,11 +34,29 @@ module RuboCop
       #     end
       #   end
       #
+      # @example EnforcedStyle: explicit
+      #   # bad
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('.success')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('books.create.success')
+      #     end
+      #   end
+      #
       class I18nLazyLookup < Base
+        include ConfigurableEnforcedStyle
         include VisibilityHelp
         extend AutoCorrector
 
-        MSG = 'Use "lazy" lookup for the text used in controllers.'
+        MSG = 'Use %<style>s lookup for the text used in controllers.'
 
         RESTRICT_ON_SEND = %i[translate t].freeze
 
@@ -42,23 +66,45 @@ module RuboCop
 
         def on_send(node)
           translate_call?(node) do |key_node|
-            key = key_node.value
-            return if key.to_s.start_with?('.')
+            case style
+            when :lazy
+              handle_lazy_style(node, key_node)
+            when :explicit
+              handle_explicit_style(node, key_node)
+            end
+          end
+        end
+
+        private
 
-            controller, action = controller_and_action(node)
-            return unless controller && action
+        def handle_lazy_style(node, key_node)
+          key = key_node.value
+          return if key.to_s.start_with?('.')
 
-            scoped_key = get_scoped_key(key_node, controller, action)
-            return unless key == scoped_key
+          controller, action = controller_and_action(node)
+          return unless controller && action
 
-            add_offense(key_node) do |corrector|
-              unscoped_key = key_node.value.to_s.split('.').last
-              corrector.replace(key_node, "'.#{unscoped_key}'")
-            end
+          scoped_key = get_scoped_key(key_node, controller, action)
+          return unless key == scoped_key
+
+          add_offense(key_node) do |corrector|
+            unscoped_key = key_node.value.to_s.split('.').last
+            corrector.replace(key_node, "'.#{unscoped_key}'")
           end
         end
 
-        private
+        def handle_explicit_style(node, key_node)
+          key = key_node.value
+          return unless key.to_s.start_with?('.')
+
+          controller, action = controller_and_action(node)
+          return unless controller && action
+
+          scoped_key = get_scoped_key(key_node, controller, action)
+          add_offense(key_node) do |corrector|
+            corrector.replace(key_node, "'#{scoped_key}'")
+          end
+        end
 
         def controller_and_action(node)
           action_node = node.each_ancestor(:def).first
@@ -90,6 +136,10 @@ module RuboCop
 
           path.delete_suffix('Controller').underscore
         end
+
+        def message(_range)
+          format(MSG, style: style)
+        end
       end
     end
   end

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

@@ -33,6 +33,7 @@ module RuboCop
 
           add_offense(node.loc.selector)
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -222,7 +222,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.first_argument, recv)
           end
           blocks.flat_map { |n| n.send_node.arguments }
         end

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

@@ -122,24 +122,23 @@ module RuboCop
           parent = node.each_ancestor(:class, :module).first
           return unless parent
 
+          # NOTE: a `:begin` node may not exist if the class/module consists of a single statement
           block = parent.each_child_node(:begin).first
-          return unless block
-
           defined_action_methods = defined_action_methods(block)
 
-          methods = array_values(methods_node).reject do |method|
-            defined_action_methods.include?(method)
-          end
+          unmatched_methods = array_values(methods_node) - defined_action_methods
+          return if unmatched_methods.empty?
 
-          message = message(methods, parent)
-          add_offense(node, message: message) unless methods.empty?
+          message = message(unmatched_methods, parent)
+          add_offense(node, message: message)
         end
 
         private
 
         def defined_action_methods(block)
-          defined_methods = block.each_child_node(:def).map(&:method_name)
+          return [] unless block
 
+          defined_methods = block.each_child_node(:def).map(&:method_name)
           defined_methods + aliased_action_methods(block, defined_methods)
         end
 

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

@@ -3,8 +3,13 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks for add_column call with NOT NULL constraint
-      # in migration file.
+      # Checks for add_column call with NOT NULL constraint in migration file.
+      #
+      # `TEXT` can have default values in PostgreSQL, but not in MySQL.
+      # It will automatically detect an adapter from `development` environment
+      # in `config/database.yml` or the environment variable `DATABASE_URL`
+      # when the `Database` option is not set. If the database is MySQL,
+      # this cop ignores offenses for the `TEXT`.
       #
       # @example
       #   # bad
@@ -17,6 +22,8 @@ module RuboCop
       #   add_reference :products, :category
       #   add_reference :products, :category, null: false, default: 1
       class NotNullColumn < Base
+        include DatabaseTypeResolvable
+
         MSG = 'Do not add a NOT NULL column without a default value.'
         RESTRICT_ON_SEND = %i[add_column add_reference].freeze
 
@@ -45,7 +52,10 @@ module RuboCop
 
         def check_add_column(node)
           add_not_null_column?(node) do |type, pairs|
-            return if type.respond_to?(:value) && (type.value == :virtual || type.value == 'virtual')
+            if type.respond_to?(:value)
+              return if type.value == :virtual || type.value == 'virtual'
+              return if (type.value == :text || type.value == 'text') && database == MYSQL
+            end
 
             check_pairs(pairs)
           end

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

@@ -23,6 +23,7 @@ module RuboCop
 
         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
+        ALLOWED_TYPES = %i[send csend block numblock].freeze
 
         def_node_matcher :output?, <<~PATTERN
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
@@ -39,8 +40,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if node.parent&.call_type?
-          return unless output?(node) || io_output?(node)
+          return if ALLOWED_TYPES.include?(node.parent&.type)
+          return if !output?(node) && !io_output?(node)
 
           range = offense_range(node)
 

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

@@ -28,13 +28,13 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Prefer `pick(%<args>s)` over `pluck(%<args>s).first`.'
+        MSG = 'Prefer `pick(%<args>s)` over `%<current>s`.'
         RESTRICT_ON_SEND = %i[first].freeze
 
         minimum_target_rails_version 6.0
 
         def_node_matcher :pick_candidate?, <<~PATTERN
-          (send (send _ :pluck ...) :first)
+          (call (call _ :pluck ...) :first)
         PATTERN
 
         def on_send(node)
@@ -44,7 +44,7 @@ module RuboCop
             node_selector = node.loc.selector
             range = receiver_selector.join(node_selector)
 
-            add_offense(range, message: message(receiver)) do |corrector|
+            add_offense(range, message: message(receiver, range)) do |corrector|
               first_range = receiver.source_range.end.join(node_selector)
 
               corrector.remove(first_range)
@@ -52,11 +52,12 @@ module RuboCop
             end
           end
         end
+        alias on_csend on_send
 
         private
 
-        def message(receiver)
-          format(MSG, args: receiver.arguments.map(&:source).join(', '))
+        def message(receiver, current)
+          format(MSG, args: receiver.arguments.map(&:source).join(', '), current: current.source)
         end
       end
     end

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

@@ -38,7 +38,7 @@ module RuboCop
         minimum_target_rails_version 5.0
 
         def_node_matcher :pluck_candidate?, <<~PATTERN
-          ({block numblock} (send _ {:map :collect}) $_argument (send lvar :[] $_key))
+          ({block numblock} (call _ {:map :collect}) $_argument (send lvar :[] $_key))
         PATTERN
 
         def on_block(node)

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

@@ -34,7 +34,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[pluck].freeze
 
         def_node_matcher :pluck_id_call?, <<~PATTERN
-          (send _ :pluck {(sym :id) (send nil? :primary_key)})
+          (call _ :pluck {(sym :id) (send nil? :primary_key)})
         PATTERN
 
         def on_send(node)
@@ -47,6 +47,7 @@ module RuboCop
             corrector.replace(offense_range(node), 'ids')
           end
         end
+        alias on_csend on_send
 
         private
 

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

@@ -22,10 +22,13 @@ module RuboCop
       # @example
       #   # bad
       #   Post.where(user_id: User.active.pluck(:id))
+      #   Post.where(user_id: User.active.ids)
+      #   Post.where.not(user_id: User.active.pluck(:id))
       #
       #   # good
       #   Post.where(user_id: User.active.select(:id))
       #   Post.where(user_id: active_users.select(:id))
+      #   Post.where.not(user_id: active_users.select(:id))
       #
       # @example EnforcedStyle: conservative (default)
       #   # good
@@ -40,8 +43,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        MSG = 'Use `select` instead of `pluck` within `where` query method.'
-        RESTRICT_ON_SEND = %i[pluck].freeze
+        MSG_SELECT = 'Use `select` instead of `pluck` within `where` query method.'
+        MSG_IDS = 'Use `select(:id)` instead of `ids` within `where` query method.'
+        RESTRICT_ON_SEND = %i[pluck ids].freeze
 
         def on_send(node)
           return unless in_where?(node)
@@ -49,17 +53,26 @@ module RuboCop
 
           range = node.loc.selector
 
-          add_offense(range) do |corrector|
-            corrector.replace(range, 'select')
+          if node.method?(:ids)
+            replacement = 'select(:id)'
+            message = MSG_IDS
+          else
+            replacement = 'select'
+            message = MSG_SELECT
+          end
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, replacement)
           end
         end
+        alias on_csend on_send
 
         private
 
         def root_receiver(node)
           receiver = node.receiver
 
-          if receiver&.send_type?
+          if receiver&.call_type?
             root_receiver(receiver)
           else
             receiver

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

@@ -45,16 +45,24 @@ module RuboCop
             return if with_dependencies?(task_method)
 
             add_offense(task_method) do |corrector|
-              task_name = task_method.arguments[0]
-              task_dependency = correct_task_dependency(task_name)
-
-              corrector.replace(task_name, task_dependency)
+              if with_arguments?(task_method)
+                new_task_dependency = correct_task_arguments_dependency(task_method)
+                corrector.replace(task_arguments(task_method), new_task_dependency)
+              else
+                task_name = task_method.first_argument
+                new_task_dependency = correct_task_dependency(task_name)
+                corrector.replace(task_name, new_task_dependency)
+              end
             end
           end
         end
 
         private
 
+        def correct_task_arguments_dependency(task_method)
+          "#{task_arguments(task_method).source} => :environment"
+        end
+
         def correct_task_dependency(task_name)
           if task_name.sym_type?
             "#{task_name.source.delete(':|\'|"')}: :environment"
@@ -64,7 +72,7 @@ module RuboCop
         end
 
         def task_name(node)
-          first_arg = node.arguments[0]
+          first_arg = node.first_argument
           case first_arg&.type
           when :sym, :str
             first_arg.value.to_sym
@@ -80,8 +88,16 @@ module RuboCop
           end
         end
 
+        def task_arguments(node)
+          node.arguments[1]
+        end
+
+        def with_arguments?(node)
+          node.arguments.size > 1 && node.arguments[1].array_type?
+        end
+
         def with_dependencies?(node)
-          first_arg = node.arguments[0]
+          first_arg = node.first_argument
           return false unless first_arg
 
           if first_arg.hash_type?