rubocop-rails 2.9.1 → 2.11.2

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

@@ -18,6 +18,7 @@ module RuboCop
       #   get :new, params: { user_id: 1 }
       #   get :new, **options
       class HttpPositionalArguments < Base
+        include RangeHelp
         extend AutoCorrector
         extend TargetRailsVersion
 
@@ -44,7 +45,7 @@ module RuboCop
 
             message = format(MSG, verb: node.method_name)
 
-            add_offense(node.loc.selector, message: message) do |corrector|
+            add_offense(highlight_range(node), message: message) do |corrector|
               # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
               #
               # @return lambda of auto correct procedure
@@ -80,6 +81,12 @@ module RuboCop
           node.sym_type? && node.value == :format
         end
 
+        def highlight_range(node)
+          _http_path, *data = *node.arguments
+
+          range_between(data.first.source_range.begin_pos, data.last.source_range.end_pos)
+        end
+
         def convert_hash_data(data, type)
           return '' if data.hash_type? && data.empty?
 

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

@@ -11,12 +11,14 @@ module RuboCop
       #   render json: { foo: 'bar' }, status: 200
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
+      #   head 200
       #
       #   # good
       #   render :foo, status: :ok
       #   render json: { foo: 'bar' }, status: :ok
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
       #
       # @example EnforcedStyle: numeric
       #   # bad
@@ -24,23 +26,26 @@ module RuboCop
       #   render json: { foo: 'bar' }, status: :not_found
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
+      #   head :ok
       #
       #   # good
       #   render :foo, status: 200
       #   render json: { foo: 'bar' }, status: 404
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
+      #   head 200
       #
       class HttpStatus < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        RESTRICT_ON_SEND = %i[render redirect_to].freeze
+        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
 
         def_node_matcher :http_status, <<~PATTERN
           {
             (send nil? {:render :redirect_to} _ $hash)
             (send nil? {:render :redirect_to} $hash)
+            (send nil? :head ${int sym} ...)
           }
         PATTERN
 
@@ -49,8 +54,12 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          http_status(node) do |hash_node|
-            status = status_code(hash_node)
+          http_status(node) do |hash_node_or_status_code|
+            status = if hash_node_or_status_code.hash_type?
+                       status_code(hash_node_or_status_code)
+                     else
+                       hash_node_or_status_code
+                     end
             return unless status
 
             checker = checker_class.new(status)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of `I18n.locale=` method.
+      #
+      # The `locale` attribute persists for the rest of the Ruby runtime, potentially causing
+      # unexpected behavior at a later time.
+      # Using `I18n.with_locale` ensures the code passed in the block is the only place `I18n.locale` is affected.
+      # It eliminates the possibility of a `locale` sticking around longer than intended.
+      #
+      # @example
+      #   # bad
+      #   I18n.locale = :fr
+      #
+      #   # good
+      #   I18n.with_locale(:fr) do
+      #   end
+      #
+      class I18nLocaleAssignment < Base
+        MSG = 'Use `I18n.with_locale` with block instead of `I18n.locale=`.'
+        RESTRICT_ON_SEND = %i[locale=].freeze
+
+        def_node_matcher :i18n_locale_assignment?, <<~PATTERN
+          (send (const {nil? cbase} :I18n) :locale= ...)
+        PATTERN
+
+        def on_send(node)
+          return unless i18n_locale_assignment?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -130,8 +130,7 @@ module RuboCop
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
       class InverseOf < Base
         SPECIFY_MSG = 'Specify an `:inverse_of` option.'
-        NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to ' \
-          'use `inverse_of: false`.'
+        NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to use `inverse_of: false`.'
         RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
 
         def_node_matcher :association_recv_arguments, <<~PATTERN

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

@@ -79,7 +79,11 @@ module RuboCop
           opening_quote = offence_node.children.last.source[0]
           closing_quote = opening_quote == ':' ? '' : opening_quote
           new_rel_exp = ", rel: #{opening_quote}noopener#{closing_quote}"
-          range = send_node.arguments.last.source_range
+          range = if (last_argument = send_node.last_argument).hash_type?
+                    last_argument.pairs.last.source_range
+                  else
+                    last_argument.source_range
+                  end
 
           corrector.insert_after(range, new_rel_exp)
         end

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

@@ -5,6 +5,8 @@ module RuboCop
     module Rails
       # This cop checks if the value of the option `class_name`, in
       # the definition of a reflection is a string.
+      # It is marked as unsafe because it cannot be determined whether
+      # constant or method return value specified to `class_name` is a string.
       #
       # @example
       #   # bad
@@ -16,6 +18,7 @@ module RuboCop
       class ReflectionClassName < Base
         MSG = 'Use a string value for `class_name`.'
         RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
+        ALLOWED_REFLECTION_CLASS_TYPES = %i[dstr str sym].freeze
 
         def_node_matcher :association_with_reflection, <<~PATTERN
           (send nil? {:has_many :has_one :belongs_to} _ _ ?
@@ -24,7 +27,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :reflection_class_name, <<~PATTERN
-          (pair (sym :class_name) [!dstr !str !sym])
+          (pair (sym :class_name) #reflection_class_value?)
         PATTERN
 
         def on_send(node)
@@ -32,6 +35,16 @@ module RuboCop
             add_offense(reflection_class_name.loc.expression)
           end
         end
+
+        private
+
+        def reflection_class_value?(class_value)
+          if class_value.send_type?
+            !class_value.method?(:to_s) || class_value.receiver&.const_type?
+          else
+            !ALLOWED_REFLECTION_CLASS_TYPES.include?(class_value.type)
+          end
+        end
       end
     end
   end

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

@@ -31,11 +31,12 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not assign %<method_name>s to constants as it ' \
+        MSG = 'Do not assign `%<method_name>s` to constants as it ' \
               'will be evaluated only once.'
+        RELATIVE_DATE_METHODS = %i[since from_now after ago until before yesterday tomorrow].to_set.freeze
 
         def on_casgn(node)
-          relative_date_assignment?(node) do |method_name|
+          nested_relative_date(node) do |method_name|
             add_offense(node, message: message(method_name)) do |corrector|
               autocorrect(corrector, node)
             end
@@ -50,7 +51,7 @@ module RuboCop
           lhs.children.zip(rhs.children).each do |(name, value)|
             next unless name.casgn_type?
 
-            relative_date?(value) do |method_name|
+            nested_relative_date(value) do |method_name|
               add_offense(offense_range(name, value), message: message(method_name)) do |corrector|
                 autocorrect(corrector, node)
               end
@@ -59,7 +60,7 @@ module RuboCop
         end
 
         def on_or_asgn(node)
-          relative_date_or_assignment?(node) do |method_name|
+          relative_date_or_assignment(node) do |method_name|
             add_offense(node, message: format(MSG, method_name: method_name))
           end
         end
@@ -88,24 +89,22 @@ module RuboCop
           range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
         end
 
-        def_node_matcher :relative_date_assignment?, <<~PATTERN
-          {
-            (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))
-            (casgn _ _ ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before})))
-            (casgn _ _ ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _))
-          }
-        PATTERN
+        def nested_relative_date(node, &callback)
+          return if node.block_type?
+
+          node.each_child_node do |child|
+            nested_relative_date(child, &callback)
+          end
+
+          relative_date(node, &callback)
+        end
 
-        def_node_matcher :relative_date_or_assignment?, <<~PATTERN
-          (:or_asgn (casgn _ _) (send _ ${:since :from_now :after :ago :until :before}))
+        def_node_matcher :relative_date_or_assignment, <<~PATTERN
+          (:or_asgn (casgn _ _) (send _ $RELATIVE_DATE_METHODS))
         PATTERN
 
-        def_node_matcher :relative_date?, <<~PATTERN
-          {
-            ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before}))
-            ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _)
-            (send _ ${:since :from_now :after :ago :until :before})
-          }
+        def_node_matcher :relative_date, <<~PATTERN
+          (send _ $RELATIVE_DATE_METHODS)
         PATTERN
       end
     end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the usage of `require_dependency`.
+      #
+      # `require_dependency` is an obsolete method for Rails applications running in Zeitwerk mode.
+      # In Zeitwerk mode, the semantics should match Ruby's and no need to be defensive with load order,
+      # just refer to classes and modules normally.
+      # If the constant name is dynamic, camelize if needed, and constantize.
+      #
+      # Applications running in Zeitwerk mode should not use `require_dependency`.
+      #
+      # NOTE: This cop is disabled by default. Please enable it if you are using Zeitwerk mode.
+      #
+      # @example
+      #   # bad
+      #   require_dependency 'some_lib'
+      class RequireDependency < Base
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 6.0
+
+        MSG = 'Do not use `require_dependency` with Zeitwerk mode.'
+        RESTRICT_ON_SEND = %i[require_dependency].freeze
+
+        def_node_matcher :require_dependency_call?, <<~PATTERN
+          (send {nil? (const _ :Kernel)} :require_dependency _)
+        PATTERN
+
+        def on_send(node)
+          require_dependency_call?(node) { add_offense(node) }
+        end
+      end
+    end
+  end
+end

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

@@ -237,7 +237,7 @@ module RuboCop
 
         def check_drop_table_node(node)
           drop_table_call(node) do
-            unless node.parent.block_type?
+            unless node.parent.block_type? || node.last_argument.block_pass_type?
               add_offense(
                 node,
                 message: format(MSG, action: 'drop_table(without block)')

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks whether the migration implements
+      # either a `change` method or both an `up` and a `down`
+      # method.
+      #
+      # @example
+      #   # bad
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def up
+      #       # up migration
+      #     end
+      #
+      #     # <----- missing down method
+      #   end
+      #
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     # <----- missing up method
+      #
+      #     def down
+      #       # down migration
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def change
+      #       # reversible migration
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeMigration < ActiveRecord::Migration[6.0]
+      #     def up
+      #       # up migration
+      #     end
+      #
+      #     def down
+      #       # down migration
+      #     end
+      #   end
+      class ReversibleMigrationMethodDefinition < Base
+        MSG = 'Migrations must contain either a `change` method, or ' \
+              'both an `up` and a `down` method.'
+
+        def_node_matcher :migration_class?, <<~PATTERN
+          (class
+            (const nil? _)
+            (send
+              (const (const {nil? cbase} :ActiveRecord) :Migration)
+              :[]
+              (float _))
+            _)
+        PATTERN
+
+        def_node_matcher :change_method?, <<~PATTERN
+          [ #migration_class? `(def :change (args) _) ]
+        PATTERN
+
+        def_node_matcher :up_and_down_methods?, <<~PATTERN
+          [ #migration_class? `(def :up (args) _) `(def :down (args) _) ]
+        PATTERN
+
+        def on_class(node)
+          return if change_method?(node) || up_and_down_methods?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -44,9 +44,22 @@ module RuboCop
         RESTRICT_ON_SEND = %i[try try!].freeze
 
         def_node_matcher :try_call, <<~PATTERN
-          (send !nil? ${:try :try!} $_ ...)
+          (send _ ${:try :try!} $_ ...)
         PATTERN
 
+        # Monkey patching for `Style/RedundantSelf` of RuboCop core.
+        # rubocop:disable Style/ClassAndModuleChildren
+        class Style::RedundantSelf
+          def self.autocorrect_incompatible_with
+            [Rails::SafeNavigation]
+          end
+        end
+        # rubocop:enable Style/ClassAndModuleChildren
+
+        def self.autocorrect_incompatible_with
+          [Style::RedundantSelf]
+        end
+
         def on_send(node)
           try_call(node) do |try_method, dispatch|
             return if try_method == :try && !cop_config['ConvertTry']
@@ -64,7 +77,12 @@ module RuboCop
           method_node, *params = *node.arguments
           method = method_node.source[1..-1]
 
-          range = range_between(node.loc.dot.begin_pos, node.loc.expression.end_pos)
+          range = if node.receiver
+                    range_between(node.loc.dot.begin_pos, node.loc.expression.end_pos)
+                  else
+                    corrector.insert_before(node, 'self')
+                    node
+                  end
 
           corrector.replace(range, replacement(method, params))
         end

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

@@ -8,40 +8,33 @@ module RuboCop
       # Built on top of Ruby on Rails style guide (https://rails.rubystyle.guide#time)
       # and the article http://danilenko.org/2012/7/6/rails_timezones/
       #
-      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
-      # then only use of Time.zone is allowed.
+      # Two styles are supported for this cop. When `EnforcedStyle` is 'strict'
+      # then only use of `Time.zone` is allowed.
       #
       # When EnforcedStyle is 'flexible' then it's also allowed
-      # to use Time.in_time_zone.
-      #
-      # @example EnforcedStyle: strict
-      #   # `strict` means that `Time` should be used with `zone`.
+      # to use `Time#in_time_zone`.
       #
+      # @example
       #   # bad
       #   Time.now
-      #   Time.parse('2015-03-02 19:05:37')
-      #
-      #   # bad
-      #   Time.current
-      #   Time.at(timestamp).in_time_zone
+      #   Time.parse('2015-03-02T19:05:37')
       #
       #   # good
+      #   Time.current
       #   Time.zone.now
-      #   Time.zone.parse('2015-03-02 19:05:37')
+      #   Time.zone.parse('2015-03-02T19:05:37')
+      #   Time.zone.parse('2015-03-02T19:05:37Z') # Respect ISO 8601 format with timezone specifier.
       #
-      # @example EnforcedStyle: flexible (default)
-      #   # `flexible` allows usage of `in_time_zone` instead of `zone`.
+      # @example EnforcedStyle: strict
+      #   # `strict` means that `Time` should be used with `zone`.
       #
       #   # bad
-      #   Time.now
-      #   Time.parse('2015-03-02 19:05:37')
+      #   Time.at(timestamp).in_time_zone
       #
-      #   # good
-      #   Time.zone.now
-      #   Time.zone.parse('2015-03-02 19:05:37')
+      # @example EnforcedStyle: flexible (default)
+      #   # `flexible` allows usage of `in_time_zone` instead of `zone`.
       #
       #   # good
-      #   Time.current
       #   Time.at(timestamp).in_time_zone
       class TimeZone < Base
         include ConfigurableEnforcedStyle
@@ -58,11 +51,13 @@ module RuboCop
 
         GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
 
-        DANGEROUS_METHODS = %i[now local new parse at current].freeze
+        DANGEROUS_METHODS = %i[now local new parse at].freeze
 
         ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601
                               jisx0301 rfc3339 httpdate to_i to_f].freeze
 
+        TIMEZONE_SPECIFIER = /[A-z]/.freeze
+
         def on_const(node)
           mod, klass = *node
           # we should only check core classes
@@ -116,9 +111,10 @@ module RuboCop
         end
 
         def check_time_node(klass, node)
+          return if attach_timezone_specifier?(node.first_argument)
+
           chain = extract_method_chain(node)
           return if not_danger_chain?(chain)
-
           return check_localtime(node) if need_check_localtime?(chain)
 
           method_name = (chain & DANGEROUS_METHODS).join('.')
@@ -132,6 +128,10 @@ module RuboCop
           end
         end
 
+        def attach_timezone_specifier?(date)
+          date.respond_to?(:value) && TIMEZONE_SPECIFIER.match?(date.value.to_s[-1])
+        end
+
         def build_message(klass, method_name, node)
           if flexible?
             format(