rubocop-rails 2.20.2 → 2.25.0

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,10 +8,13 @@ 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
       #   head 200
+      #   assert_response 200
+      #   assert_redirected_to '/some/path', status: 301
       #
       #   # good
       #   render :foo, status: :ok
@@ -19,6 +22,8 @@ module RuboCop
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
       #   head :ok
+      #   assert_response :ok
+      #   assert_redirected_to '/some/path', status: :moved_permanently
       #
       # @example EnforcedStyle: numeric
       #   # bad
@@ -27,6 +32,8 @@ module RuboCop
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
       #   head :ok
+      #   assert_response :ok
+      #   assert_redirected_to '/some/path', status: :moved_permanently
       #
       #   # good
       #   render :foo, status: 200
@@ -34,23 +41,27 @@ module RuboCop
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
       #   head 200
+      #   assert_response 200
+      #   assert_redirected_to '/some/path', status: 301
       #
       class HttpStatus < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
+        RESTRICT_ON_SEND = %i[render redirect_to head assert_response assert_redirected_to].freeze
 
         def_node_matcher :http_status, <<~PATTERN
           {
             (send nil? {:render :redirect_to} _ $hash)
             (send nil? {:render :redirect_to} $hash)
-            (send nil? :head ${int sym} ...)
+            (send nil? {:head :assert_response} ${int sym} ...)
+            (send nil? :assert_redirected_to _ $hash ...)
+            (send nil? :assert_redirected_to $hash ...)
           }
         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 +119,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 +144,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,20 +3,45 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks for add_column call with NOT NULL constraint
-      # in migration file.
+      # Checks for add_column calls with a NOT NULL constraint without a default
+      # value.
+      #
+      # This cop only applies when adding a column to an existing table, since
+      # existing records will not have a value for the new column. New tables
+      # can freely use NOT NULL columns without defaults, since there are no
+      # records that could violate the constraint.
+      #
+      # If you need to add a NOT NULL column to an existing table, you must add
+      # it as nullable first, back-fill the data, and then use
+      # `change_column_null`. Alternatively, you could add the column with a
+      # default first to have the database automatically backfill existing rows,
+      # and then use `change_column_default` to remove the default.
+      #
+      # `TEXT` cannot have a default value in MySQL.
+      # The cop 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 `TEXT` columns.
       #
       # @example
       #   # bad
       #   add_column :users, :name, :string, null: false
       #   add_reference :products, :category, null: false
+      #   change_table :users do |t|
+      #     t.string :name, null: false
+      #   end
       #
       #   # good
       #   add_column :users, :name, :string, null: true
       #   add_column :users, :name, :string, null: false, default: ''
+      #   change_table :users do |t|
+      #     t.string :name, null: false, default: ''
+      #   end
       #   add_reference :products, :category
-      #   add_reference :products, :category, null: false, default: 1
+      #   change_column_null :products, :category_id, false
       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
 
@@ -28,6 +53,22 @@ module RuboCop
           (send nil? :add_reference _ _ (hash $...))
         PATTERN
 
+        def_node_matcher :change_table?, <<~PATTERN
+          (block (send nil? :change_table ...) (args (arg $_)) _)
+        PATTERN
+
+        def_node_matcher :add_not_null_column_in_change_table?, <<~PATTERN
+          (send (lvar $_) :column _ $_ (hash $...))
+        PATTERN
+
+        def_node_matcher :add_not_null_column_via_shortcut_in_change_table?, <<~PATTERN
+          (send (lvar $_) $_ _ (hash $...))
+        PATTERN
+
+        def_node_matcher :add_not_null_reference_in_change_table?, <<~PATTERN
+          (send (lvar $_) :add_reference _ _ (hash $...))
+        PATTERN
+
         def_node_matcher :null_false?, <<~PATTERN
           (pair (sym :null) (false))
         PATTERN
@@ -41,13 +82,25 @@ module RuboCop
           check_add_reference(node)
         end
 
+        def on_block(node)
+          check_change_table(node)
+        end
+        alias on_numblock on_block
+
         private
 
+        def check_column(type, pairs)
+          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
+
         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')
-
-            check_pairs(pairs)
+            check_column(type, pairs)
           end
         end
 
@@ -57,6 +110,41 @@ module RuboCop
           end
         end
 
+        def check_add_column_in_change_table(node, table)
+          add_not_null_column_in_change_table?(node) do |receiver, type, pairs|
+            next unless receiver == table
+
+            check_column(type, pairs)
+          end
+        end
+
+        def check_add_column_via_shortcut_in_change_table(node, table)
+          add_not_null_column_via_shortcut_in_change_table?(node) do |receiver, type, pairs|
+            next unless receiver == table
+
+            check_column(type, pairs)
+          end
+        end
+
+        def check_add_reference_in_change_table(node, table)
+          add_not_null_reference_in_change_table?(node) do |receiver, pairs|
+            next unless receiver == table
+
+            check_pairs(pairs)
+          end
+        end
+
+        def check_change_table(node)
+          change_table?(node) do |table|
+            children = node.body.begin_type? ? node.body.children : [node.body]
+            children.each do |child|
+              check_add_column_in_change_table(child, table)
+              check_add_column_via_shortcut_in_change_table(child, table)
+              check_add_reference_in_change_table(child, table)
+            end
+          end
+        end
+
         def check_pairs(pairs)
           return if pairs.any? { |pair| default_option?(pair) }
 

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

@@ -9,6 +9,10 @@ module RuboCop
       # `pick` avoids. When called on an Active Record relation, `pick` adds a
       # limit to the query so that only one value is fetched from the database.
       #
+      # Note that when `pick` is added to a relation with an existing limit, it
+      # causes a subquery to be added. In most cases this is undesirable, and
+      # care should be taken while resolving this violation.
+      #
       # @safety
       #   This cop is unsafe because `pluck` is defined on both `ActiveRecord::Relation` and `Enumerable`,
       #   whereas `pick` is only defined on `ActiveRecord::Relation` in Rails 6.0. This was addressed
@@ -28,13 +32,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 +48,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 +56,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