rubocop-rails 2.10.1 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79de98cdd4ff48a6ee51c47f2a0bdb76e2393aac1b7974b9181e66723922c148
-  data.tar.gz: 85c6c566a98c399bcc73b555187e37d8270975cfde4c5bc067726ee61d6c3704
+  metadata.gz: b189297521a834dca247787947efd0f3a7c5fed19b351b37d6c729b0622ff52d
+  data.tar.gz: e68accc2d7c9c5726b63967f665414d09f9d3597117de042ee9dbc024cbc6350
 SHA512:
-  metadata.gz: 7cf4cddba4e79e79579415bb93aed3bc75e8571a862f32727edc56ffbe5580ba4f5781cf7205c84dbdf1cae9979c7c4b500c227f82ba1a5d476af279a8a9f575
-  data.tar.gz: c3591c01fe64b61de0ea39d136a57697b90deb71c90c7738de7c4eb8102f0b6a03548c2e2add574d343ce025d087150d57f7b51860d7471f85943fda125fc7e4
+  metadata.gz: 2474d4d0321548d02443df1ec10e20252c5496fa6df4dd4bc5d8c0544c9ff884f23da90273075d808bfa1ef22659ee8d8b81cff4f5dbf8a8134c054adf298187
+  data.tar.gz: f7cb276a49bdaffffbc020ac96951f3e5074c4f993f77710b22a48fc7efb357d447853768f6006c7e173640e483601cd6bab61b6ffb3df5a70dffb3a07b49541

data/config/default.yml

@@ -83,6 +83,16 @@ Rails/ActiveSupportAliases:
   Enabled: true
   VersionAdded: '0.48'
 
+Rails/AddColumnIndex:
+  Description: >-
+    Rails migrations don't make use of a given `index` key, but also
+    doesn't given an error when it's used, so it makes it seem like an
+    index might be used.
+  Enabled: pending
+  VersionAdded: '2.11'
+  Include:
+    - db/migrate/*.rb
+
 Rails/AfterCommitOverride:
   Description: >-
                   This cop enforces that there is only one call to `after_commit`
@@ -193,7 +203,7 @@ Rails/Date:
                   such as Date.today, Date.current etc.
   Enabled: true
   VersionAdded: '0.30'
-  VersionChanged: '0.33'
+  VersionChanged: '2.11'
   # The value `strict` disallows usage of `Date.today`, `Date.current`,
   # `Date#to_time` etc.
   # The value `flexible` allows usage of `Date.current`, `Date.yesterday`, etc
@@ -203,6 +213,7 @@ Rails/Date:
   SupportedStyles:
     - strict
     - flexible
+  AllowToTime: true
 
 Rails/DefaultScope:
   Description: 'Avoid use of `default_scope`.'
@@ -240,6 +251,12 @@ Rails/DynamicFindBy:
   AllowedReceivers:
     - Gem::Specification
 
+Rails/EagerEvaluationLogMessage:
+  Description: 'Checks that blocks are used for interpolated strings passed to `Rails.logger.debug`.'
+  Reference: 'https://guides.rubyonrails.org/debugging_rails_applications.html#impact-of-logs-on-performance'
+  Enabled: pending
+  VersionAdded: '2.11'
+
 Rails/EnumHash:
   Description: 'Prefer hash syntax over array syntax when defining enums.'
   StyleGuide: 'https://rails.rubystyle.guide#enums'
@@ -262,8 +279,10 @@ Rails/EnvironmentComparison:
 
 Rails/EnvironmentVariableAccess:
   Description: 'Do not access `ENV` directly after initialization.'
-  Enabled: pending
+  # TODO: Set to `pending` status in RuboCop Rails 2 series when migration doc will be written.
+  Enabled: false
   VersionAdded: '2.10'
+  VersionChanged: '2.11'
   Include:
     - app/**/*.rb
     - lib/**/*.rb
@@ -286,6 +305,11 @@ Rails/Exit:
   Exclude:
     - lib/**/*.rake
 
+Rails/ExpandedDateRange:
+  Description: 'Checks for expanded date range.'
+  Enabled: pending
+  VersionAdded: '2.11'
+
 Rails/FilePath:
   Description: 'Use `Rails.root.join` for file path joining.'
   Enabled: true
@@ -301,6 +325,8 @@ Rails/FindBy:
   StyleGuide: 'https://rails.rubystyle.guide#find_by'
   Enabled: true
   VersionAdded: '0.30'
+  VersionChanged: '2.11'
+  IgnoreWhereFirst: true
   Include:
     - app/models/**/*.rb
 
@@ -362,11 +388,20 @@ Rails/HttpStatus:
   Description: 'Enforces use of symbolic or numeric value to define HTTP status.'
   Enabled: true
   VersionAdded: '0.54'
+  VersionChanged: '2.11'
   EnforcedStyle: symbolic
   SupportedStyles:
     - numeric
     - symbolic
 
+Rails/I18nLocaleAssignment:
+  Description: 'Prefer the usage of `I18n.with_locale` instead of manually updating `I18n.locale` value.'
+  Enabled: 'pending'
+  VersionAdded: '2.11'
+  Include:
+    - spec/**/*.rb
+    - test/**/*.rb
+
 Rails/IgnoredSkipActionFilterOption:
   Description: 'Checks that `if` and `only` (or `except`) are not used together as options of `skip_*` action filter.'
   Reference: 'https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options'
@@ -784,6 +819,13 @@ Rails/UnknownEnv:
     - test
     - production
 
+Rails/UnusedIgnoredColumns:
+  Description: 'Remove a column that does not exist from `ignored_columns`.'
+  Enabled: pending
+  VersionAdded: '2.11'
+  Include:
+    - app/models/**/*.rb
+
 Rails/Validation:
   Description: 'Use validates :attribute, hash of validations.'
   Enabled: true

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for migrations using `add_column` that have an `index`
+      # key. `add_column` does not accept `index`, but also does not raise an
+      # error for extra keys, so it is possible to mistakenly add the key without
+      # realizing it will not actually add an index.
+      #
+      # @example
+      #   # bad (will not add an index)
+      #   add_column :table, :column, :integer, index: true
+      #
+      #   # good
+      #   add_column :table, :column, :integer
+      #   add_index :table, :column
+      #
+      class AddColumnIndex < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = '`add_column` does not accept an `index` key, use `add_index` instead.'
+        RESTRICT_ON_SEND = %i[add_column].freeze
+
+        # @!method add_column_with_index(node)
+        def_node_matcher :add_column_with_index, <<~PATTERN
+          (
+            send nil? :add_column $_table $_column
+              <(hash <$(pair {(sym :index) (str "index")} $_) ...>) ...>
+          )
+        PATTERN
+
+        def on_send(node)
+          table, column, pair, value = add_column_with_index(node)
+          return unless pair
+
+          add_offense(pair) do |corrector|
+            corrector.remove(index_range(pair))
+
+            add_index = "add_index #{table.source}, #{column.source}"
+            add_index_opts = ''
+
+            if value.hash_type?
+              hash = value.loc.expression.adjust(begin_pos: 1, end_pos: -1).source.strip
+              add_index_opts = ", #{hash}"
+            end
+
+            corrector.insert_after(node, "\n#{add_index}#{add_index_opts}")
+          end
+        end
+
+        private
+
+        def index_range(pair_node)
+          range_with_surrounding_comma(
+            range_with_surrounding_space(range: pair_node.loc.expression, side: :left),
+            :left
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -12,20 +12,21 @@ module RuboCop
       # The cop also reports warnings when you are using `to_time` method,
       # because it doesn't know about Rails time zone either.
       #
-      # Two styles are supported for this cop. When EnforcedStyle is 'strict'
+      # Two styles are supported for this cop. When `EnforcedStyle` is 'strict'
       # then the Date methods `today`, `current`, `yesterday`, and `tomorrow`
       # are prohibited and the usage of both `to_time`
       # and 'to_time_in_current_zone' are reported as warning.
       #
-      # When EnforcedStyle is 'flexible' then only `Date.today` is prohibited
-      # and only `to_time` is reported as warning.
+      # When `EnforcedStyle` is `flexible` then only `Date.today` is prohibited.
+      #
+      # And you can set a warning for `to_time` with `AllowToTime: false`.
+      # `AllowToTime` is `true` by default to prevent false positive on `DateTime` object.
       #
       # @example EnforcedStyle: strict
       #   # bad
       #   Date.current
       #   Date.yesterday
       #   Date.today
-      #   date.to_time
       #
       #   # good
       #   Time.zone.today
@@ -34,7 +35,6 @@ module RuboCop
       # @example EnforcedStyle: flexible (default)
       #   # bad
       #   Date.today
-      #   date.to_time
       #
       #   # good
       #   Time.zone.today
@@ -43,6 +43,13 @@ module RuboCop
       #   Date.yesterday
       #   date.in_time_zone
       #
+      # @example AllowToTime: true (default)
+      #   # good
+      #   date.to_time
+      #
+      # @example AllowToTime: false
+      #   # bad
+      #   date.to_time
       class Date < Base
         include ConfigurableEnforcedStyle
 
@@ -73,7 +80,7 @@ module RuboCop
 
         def on_send(node)
           return unless node.receiver && bad_methods.include?(node.method_name)
-
+          return if allow_to_time? && node.method?(:to_time)
           return if safe_chain?(node) || safe_to_time?(node)
 
           check_deprecated_methods(node)
@@ -139,6 +146,10 @@ module RuboCop
           end
         end
 
+        def allow_to_time?
+          cop_config.fetch('AllowToTime', true)
+        end
+
         def good_days
           style == :strict ? [] : %i[current yesterday tomorrow]
         end

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

@@ -37,6 +37,7 @@ module RuboCop
 
         MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
+        IGNORED_ARGUMENT_TYPES = %i[hash splat].freeze
 
         def on_send(node)
           return if node.receiver.nil? && !inherit_active_record_base?(node) || allowed_invocation?(node)
@@ -44,7 +45,7 @@ module RuboCop
           method_name = node.method_name
           static_name = static_method_name(method_name)
           return unless static_name
-          return if node.arguments.any?(&:splat_type?)
+          return if node.arguments.any? { |argument| IGNORED_ARGUMENT_TYPES.include?(argument.type) }
 
           message = format(MSG, static_name: static_name, method: method_name)
           add_offense(node, message: message) do |corrector|

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks that blocks are used for interpolated strings passed to
+      # `Rails.logger.debug`.
+      #
+      # By default, Rails production environments use the `:info` log level.
+      # At the `:info` log level, `Rails.logger.debug` statements do not result
+      # in log output. However, Ruby must eagerly evaluate interpolated string
+      # arguments passed as method arguments. Passing a block to
+      # `Rails.logger.debug` prevents costly evaluation of interpolated strings
+      # when no output would be produced anyway.
+      #
+      # @example
+      #   #bad
+      #   Rails.logger.debug "The time is #{Time.zone.now}."
+      #
+      #   #good
+      #   Rails.logger.debug { "The time is #{Time.zone.now}." }
+      #
+      class EagerEvaluationLogMessage < Base
+        extend AutoCorrector
+
+        MSG = 'Pass a block to `Rails.logger.debug`.'
+        RESTRICT_ON_SEND = %i[debug].freeze
+
+        def_node_matcher :interpolated_string_passed_to_debug, <<~PATTERN
+          (send
+            (send
+              (const {cbase nil?} :Rails)
+              :logger
+            )
+            :debug
+            $(dstr ...)
+          )
+        PATTERN
+
+        def on_send(node)
+          return if node.parent&.block_type?
+
+          interpolated_string_passed_to_debug(node) do |arguments|
+            message = format(MSG)
+
+            range = replacement_range(node)
+            replacement = replacement_source(node, arguments)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, replacement)
+            end
+          end
+        end
+
+        private
+
+        def replacement_range(node)
+          stop = node.loc.expression.end
+          start = node.loc.selector.end
+
+          if node.parenthesized_call?
+            stop.with(begin_pos: start.begin_pos)
+          else
+            stop.with(begin_pos: start.begin_pos + 1)
+          end
+        end
+
+        def replacement_source(node, arguments)
+          if node.parenthesized_call?
+            " { #{arguments.source} }"
+          else
+            "{ #{arguments.source} }"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for expanded date range. It only compatible `..` range is targeted.
+      # Incompatible `...` range is ignored.
+      #
+      # @example
+      #   # bad
+      #   date.beginning_of_day..date.end_of_day
+      #   date.beginning_of_week..date.end_of_week
+      #   date.beginning_of_month..date.end_of_month
+      #   date.beginning_of_quarter..date.end_of_quarter
+      #   date.beginning_of_year..date.end_of_year
+      #
+      #   # good
+      #   date.all_day
+      #   date.all_week
+      #   date.all_month
+      #   date.all_quarter
+      #   date.all_year
+      #
+      class ExpandedDateRange < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<preferred_method>s` instead.'
+
+        minimum_target_rails_version 5.1
+
+        def_node_matcher :expanded_date_range, <<~PATTERN
+          (irange
+            (send
+              $_ {:beginning_of_day :beginning_of_week :beginning_of_month :beginning_of_quarter :beginning_of_year})
+            (send
+              $_ {:end_of_day :end_of_week :end_of_month :end_of_quarter :end_of_year}))
+        PATTERN
+
+        PREFERRED_METHODS = {
+          beginning_of_day: 'all_day',
+          beginning_of_week: 'all_week',
+          beginning_of_month: 'all_month',
+          beginning_of_quarter: 'all_quarter',
+          beginning_of_year: 'all_year'
+        }.freeze
+
+        MAPPED_DATE_RANGE_METHODS = {
+          beginning_of_day: :end_of_day,
+          beginning_of_week: :end_of_week,
+          beginning_of_month: :end_of_month,
+          beginning_of_quarter: :end_of_quarter,
+          beginning_of_year: :end_of_year
+        }.freeze
+
+        def on_irange(node)
+          return unless expanded_date_range(node)
+
+          begin_node = node.begin
+          end_node = node.end
+          return unless same_receiver?(begin_node, end_node)
+
+          beginning_method = begin_node.method_name
+          end_method = end_node.method_name
+          return unless use_mapped_methods?(beginning_method, end_method)
+
+          preferred_method = "#{begin_node.receiver.source}.#{PREFERRED_METHODS[beginning_method]}"
+
+          add_offense(node, message: format(MSG, preferred_method: preferred_method)) do |corrector|
+            corrector.replace(node, preferred_method)
+          end
+        end
+
+        private
+
+        def same_receiver?(begin_node, end_node)
+          begin_node.receiver.source == end_node.receiver.source
+        end
+
+        def use_mapped_methods?(beginning_method, end_method)
+          MAPPED_DATE_RANGE_METHODS[beginning_method] == end_method
+        end
+      end
+    end
+  end
+end

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

@@ -3,16 +3,27 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of `where.first` and
-      # change them to use `find_by` instead.
+      # This cop is used to identify usages of `where.take` and change them to use `find_by` instead.
+      #
+      # And `where(...).first` can return different results from `find_by`.
+      # (They order records differently, so the "first" record can be different.)
+      #
+      # If you also want to detect `where.first`, you can set `IgnoreWhereFirst` to false.
       #
       # @example
       #   # bad
-      #   User.where(name: 'Bruce').first
       #   User.where(name: 'Bruce').take
       #
       #   # good
       #   User.find_by(name: 'Bruce')
+      #
+      # @example IgnoreWhereFirst: true (default)
+      #   # good
+      #   User.where(name: 'Bruce').first
+      #
+      # @example IgnoreWhereFirst: false
+      #   # bad
+      #   User.where(name: 'Bruce').first
       class FindBy < Base
         include RangeHelp
         extend AutoCorrector
@@ -20,12 +31,8 @@ module RuboCop
         MSG = 'Use `find_by` instead of `where.%<method>s`.'
         RESTRICT_ON_SEND = %i[first take].freeze
 
-        def_node_matcher :where_first?, <<~PATTERN
-          (send ({send csend} _ :where ...) {:first :take})
-        PATTERN
-
         def on_send(node)
-          return unless where_first?(node)
+          return if ignore_where_first? && node.method?(:first)
 
           range = range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
 
@@ -38,9 +45,6 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          # Don't autocorrect where(...).first, because it can return different
-          # results from find_by. (They order records differently, so the
-          # 'first' record can be different.)
           return if node.method?(:first)
 
           where_loc = node.receiver.loc.selector
@@ -49,6 +53,10 @@ module RuboCop
           corrector.replace(where_loc, 'find_by')
           corrector.replace(first_loc, '')
         end
+
+        def ignore_where_first?
+          cop_config.fetch('IgnoreWhereFirst', true)
+        end
       end
     end
   end

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

@@ -33,16 +33,12 @@ module RuboCop
 
         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].freeze
+        RELATIVE_DATE_METHODS = %i[since from_now after ago until before yesterday tomorrow].to_set.freeze
 
         def on_casgn(node)
-          return if node.children[2]&.block_type?
-
-          node.each_descendant(:send) do |send_node|
-            relative_date?(send_node) do |method_name|
-              add_offense(node, message: message(method_name)) do |corrector|
-                autocorrect(corrector, node)
-              end
+          nested_relative_date(node) do |method_name|
+            add_offense(node, message: message(method_name)) do |corrector|
+              autocorrect(corrector, node)
             end
           end
         end
@@ -55,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
@@ -64,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
@@ -93,20 +89,22 @@ module RuboCop
           range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
         end
 
-        def relative_date_method?(method_name)
-          RELATIVE_DATE_METHODS.include?(method_name)
+        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 _ $#relative_date_method?))
+        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 _ $#relative_date_method?))
-            ({erange irange} (send _ $#relative_date_method?) _)
-            (send _ $#relative_date_method?)
-          }
+        def_node_matcher :relative_date, <<~PATTERN
+          (send _ $RELATIVE_DATE_METHODS)
         PATTERN
       end
     end

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

@@ -50,7 +50,7 @@ module RuboCop
           (class
             (const nil? _)
             (send
-              (const (const nil? :ActiveRecord) :Migration)
+              (const (const {nil? cbase} :ActiveRecord) :Migration)
               :[]
               (float _))
             _)

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

@@ -8,41 +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-02T19:05:37')
       #
-      #   # bad
-      #   Time.current
-      #   Time.at(timestamp).in_time_zone
-      #
       #   # good
+      #   Time.current
       #   Time.zone.now
       #   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-02T19:05:37')
+      #   Time.at(timestamp).in_time_zone
       #
-      #   # good
-      #   Time.zone.now
-      #   Time.zone.parse('2015-03-02T19: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
@@ -59,7 +51,7 @@ 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

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

@@ -6,8 +6,8 @@ module RuboCop
       # This cop checks for the use of `Time.zone=` method.
       #
       # The `zone` attribute persists for the rest of the Ruby runtime, potentially causing
-      # unexpected behaviour at a later time.
-      # Using `Time.use_zone` ensures the code passed in block is the only place Time.zone is affected.
+      # unexpected behavior at a later time.
+      # Using `Time.use_zone` ensures the code passed in the block is the only place Time.zone is affected.
       # It eliminates the possibility of a `zone` sticking around longer than intended.
       #
       # @example
@@ -19,7 +19,7 @@ module RuboCop
       #   end
       #
       class TimeZoneAssignment < Base
-        MSG = 'Use `Time.use_zone` with blocks instead of `Time.zone=`.'
+        MSG = 'Use `Time.use_zone` with block instead of `Time.zone=`.'
         RESTRICT_ON_SEND = %i[zone=].freeze
 
         def_node_matcher :time_zone_assignement?, <<~PATTERN

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop suggests you remove a column that does not exist in the schema from `ignored_columns`.
+      # `ignored_columns` is necessary to drop a column from RDBMS, but you don't need it after the migration
+      # to drop the column. You avoid forgetting to remove `ignored_columns` by this cop.
+      #
+      # @example
+      #   # bad
+      #   class User < ApplicationRecord
+      #     self.ignored_columns = [:already_removed_column]
+      #   end
+      #
+      #   # good
+      #   class User < ApplicationRecord
+      #     self.ignored_columns = [:still_existing_column]
+      #   end
+      #
+      class UnusedIgnoredColumns < Base
+        include ActiveRecordHelper
+
+        MSG = 'Remove `%<column_name>s` from `ignored_columns` because the column does not exist.'
+        RESTRICT_ON_SEND = %i[ignored_columns=].freeze
+
+        def_node_matcher :ignored_columns, <<~PATTERN
+          (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 schema
+
+          table = table(node)
+          return unless table
+
+          columns.children.each do |column_node|
+            check_column_existence(column_node, table)
+          end
+        end
+
+        private
+
+        def check_column_existence(column_node, table)
+          column_name = column_name(column_node)
+          return unless column_name
+          return if table.with_column?(name: column_name.to_s)
+
+          message = format(MSG, column_name: column_name)
+          add_offense(column_node, message: message)
+        end
+
+        def class_node(node)
+          node.each_ancestor.find(&:class_type?)
+        end
+
+        def table(node)
+          klass = class_node(node)
+          schema.table_by(name: table_name(klass))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -10,6 +10,7 @@ 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/add_column_index'
 require_relative 'rails/after_commit_override'
 require_relative 'rails/application_controller'
 require_relative 'rails/application_job'
@@ -28,11 +29,13 @@ require_relative 'rails/default_scope'
 require_relative 'rails/delegate'
 require_relative 'rails/delegate_allow_blank'
 require_relative 'rails/dynamic_find_by'
+require_relative 'rails/eager_evaluation_log_message'
 require_relative 'rails/enum_hash'
 require_relative 'rails/enum_uniqueness'
 require_relative 'rails/environment_comparison'
 require_relative 'rails/environment_variable_access'
 require_relative 'rails/exit'
+require_relative 'rails/expanded_date_range'
 require_relative 'rails/file_path'
 require_relative 'rails/find_by'
 require_relative 'rails/find_by_id'
@@ -42,6 +45,7 @@ require_relative 'rails/has_many_or_has_one_dependent'
 require_relative 'rails/helper_instance_variable'
 require_relative 'rails/http_positional_arguments'
 require_relative 'rails/http_status'
+require_relative 'rails/i18n_locale_assignment'
 require_relative 'rails/ignored_skip_action_filter_option'
 require_relative 'rails/index_by'
 require_relative 'rails/index_with'
@@ -89,6 +93,7 @@ require_relative 'rails/time_zone_assignment'
 require_relative 'rails/uniq_before_pluck'
 require_relative 'rails/unique_validation_without_index'
 require_relative 'rails/unknown_env'
+require_relative 'rails/unused_ignored_columns'
 require_relative 'rails/validation'
 require_relative 'rails/where_equals'
 require_relative 'rails/where_exists'

data/lib/rubocop/rails/schema_loader/schema.rb

@@ -114,7 +114,7 @@ module RuboCop
         attr_reader :name, :type, :not_null
 
         def initialize(node)
-          @name = node.first_argument.value
+          @name = node.first_argument.str_content
           @type = node.method_name
           @not_null = nil
 

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.10.1'
+      STRING = '2.11.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rails
 version: !ruby/object:Gem::Version
-  version: 2.10.1
+  version: 2.11.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-05-05 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -85,6 +85,7 @@ files:
 - lib/rubocop/cop/rails/active_record_callbacks_order.rb
 - lib/rubocop/cop/rails/active_record_override.rb
 - lib/rubocop/cop/rails/active_support_aliases.rb
+- lib/rubocop/cop/rails/add_column_index.rb
 - lib/rubocop/cop/rails/after_commit_override.rb
 - lib/rubocop/cop/rails/application_controller.rb
 - lib/rubocop/cop/rails/application_job.rb
@@ -103,11 +104,13 @@ files:
 - lib/rubocop/cop/rails/delegate.rb
 - lib/rubocop/cop/rails/delegate_allow_blank.rb
 - lib/rubocop/cop/rails/dynamic_find_by.rb
+- lib/rubocop/cop/rails/eager_evaluation_log_message.rb
 - lib/rubocop/cop/rails/enum_hash.rb
 - lib/rubocop/cop/rails/enum_uniqueness.rb
 - lib/rubocop/cop/rails/environment_comparison.rb
 - lib/rubocop/cop/rails/environment_variable_access.rb
 - lib/rubocop/cop/rails/exit.rb
+- lib/rubocop/cop/rails/expanded_date_range.rb
 - lib/rubocop/cop/rails/file_path.rb
 - lib/rubocop/cop/rails/find_by.rb
 - lib/rubocop/cop/rails/find_by_id.rb
@@ -117,6 +120,7 @@ files:
 - lib/rubocop/cop/rails/helper_instance_variable.rb
 - lib/rubocop/cop/rails/http_positional_arguments.rb
 - lib/rubocop/cop/rails/http_status.rb
+- lib/rubocop/cop/rails/i18n_locale_assignment.rb
 - lib/rubocop/cop/rails/ignored_skip_action_filter_option.rb
 - lib/rubocop/cop/rails/index_by.rb
 - lib/rubocop/cop/rails/index_with.rb
@@ -164,6 +168,7 @@ files:
 - lib/rubocop/cop/rails/uniq_before_pluck.rb
 - lib/rubocop/cop/rails/unique_validation_without_index.rb
 - lib/rubocop/cop/rails/unknown_env.rb
+- lib/rubocop/cop/rails/unused_ignored_columns.rb
 - lib/rubocop/cop/rails/validation.rb
 - lib/rubocop/cop/rails/where_equals.rb
 - lib/rubocop/cop/rails/where_exists.rb
@@ -181,7 +186,7 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-rails/
   changelog_uri: https://github.com/rubocop/rubocop-rails/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-rails/
-  documentation_uri: https://docs.rubocop.org/rubocop-rails/2.10/
+  documentation_uri: https://docs.rubocop.org/rubocop-rails/2.11/
   bug_tracker_uri: https://github.com/rubocop/rubocop-rails/issues
 post_install_message:
 rdoc_options: []
@@ -198,7 +203,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.2.18
 signing_key:
 specification_version: 4
 summary: Automatic Rails code style checking tool.