rubocop-rails 2.8.1 → 2.11.0

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

@@ -7,7 +7,7 @@ module RuboCop
       # validations which are listed in
       # https://guides.rubyonrails.org/active_record_validations.html#skipping-validations
       #
-      # Methods may be ignored from this rule by configuring a `Whitelist`.
+      # Methods may be ignored from this rule by configuring a `AllowedMethods`.
       #
       # @example
       #   # bad
@@ -26,7 +26,7 @@ module RuboCop
       #   user.update(website: 'example.com')
       #   FileUtils.touch('file')
       #
-      # @example Whitelist: ["touch"]
+      # @example AllowedMethods: ["touch"]
       #   # bad
       #   DiscussionBoard.decrement_counter(:post_count, 5)
       #   DiscussionBoard.increment_counter(:post_count, 5)
@@ -35,7 +35,7 @@ module RuboCop
       #   # good
       #   user.touch
       #
-      class SkipsModelValidations < Cop
+      class SkipsModelValidations < Base
         MSG = 'Avoid using `%<method>s` because it skips validations.'
 
         METHODS_WITH_ARGUMENTS = %w[decrement!
@@ -76,7 +76,7 @@ module RuboCop
           return if good_touch?(node)
           return if good_insert?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector, message: message(node))
         end
         alias on_csend on_send
 

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

@@ -5,6 +5,8 @@ module RuboCop
     module Rails
       #
       # Checks SQL heredocs to use `.squish`.
+      # Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
+      # to be preserved in order to work, thus auto-correction for this cop is not safe.
       #
       # @example
       #   # bad
@@ -37,8 +39,9 @@ module RuboCop
       #       WHERE post_id = 1
       #   SQL
       #
-      class SquishedSQLHeredocs < Cop
+      class SquishedSQLHeredocs < Base
         include Heredoc
+        extend AutoCorrector
 
         SQL = 'SQL'
         SQUISH = '.squish'
@@ -47,11 +50,7 @@ module RuboCop
         def on_heredoc(node)
           return unless offense_detected?(node)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.insert_after(node, SQUISH)
           end
         end

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

@@ -8,43 +8,37 @@ 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 < Cop
+      class TimeZone < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` ' \
               'instead.'
@@ -57,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
@@ -71,26 +67,24 @@ module RuboCop
           check_time_node(klass, node.parent) if klass == :Time
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            # add `.zone`: `Time.at` => `Time.zone.at`
-            corrector.insert_after(node.children[0].source_range, '.zone')
+        private
 
-            case node.method_name
-            when :current
-              # replace `Time.zone.current` => `Time.zone.now`
-              corrector.replace(node.loc.selector, 'now')
-            when :new
-              autocorrect_time_new(node, corrector)
-            end
+        def autocorrect(corrector, node)
+          # add `.zone`: `Time.at` => `Time.zone.at`
+          corrector.insert_after(node.children[0].source_range, '.zone')
 
-            # prefer `Time` over `DateTime` class
-            corrector.replace(node.children.first.source_range, 'Time') if strict?
-            remove_redundant_in_time_zone(corrector, node)
+          case node.method_name
+          when :current
+            # replace `Time.zone.current` => `Time.zone.now`
+            corrector.replace(node.loc.selector, 'now')
+          when :new
+            autocorrect_time_new(node, corrector)
           end
-        end
 
-        private
+          # prefer `Time` over `DateTime` class
+          corrector.replace(node.children.first.source_range, 'Time') if strict?
+          remove_redundant_in_time_zone(corrector, node)
+        end
 
         def autocorrect_time_new(node, corrector)
           if node.arguments?
@@ -117,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('.')
@@ -128,7 +123,13 @@ module RuboCop
 
           message = build_message(klass, method_name, node)
 
-          add_offense(node, location: :selector, message: message)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            autocorrect(corrector, node)
+          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)
@@ -193,8 +194,9 @@ module RuboCop
 
           return if node.arguments?
 
-          add_offense(selector_node,
-                      location: :selector, message: MSG_LOCALTIME)
+          add_offense(selector_node.loc.selector, message: MSG_LOCALTIME) do |corrector|
+            autocorrect(corrector, selector_node)
+          end
         end
 
         def not_danger_chain?(chain)

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for the use of `Time.zone=` method.
+      #
+      # The `zone` attribute persists for the rest of the Ruby runtime, potentially causing
+      # 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
+      #   # bad
+      #   Time.zone = 'EST'
+      #
+      #   # good
+      #   Time.use_zone('EST') do
+      #   end
+      #
+      class TimeZoneAssignment < Base
+        MSG = 'Use `Time.use_zone` with block instead of `Time.zone=`.'
+        RESTRICT_ON_SEND = %i[zone=].freeze
+
+        def_node_matcher :time_zone_assignement?, <<~PATTERN
+          (send (const nil? :Time) :zone= ...)
+        PATTERN
+
+        def on_send(node)
+          return unless time_zone_assignement?(node)
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -45,11 +45,13 @@ module RuboCop
       #   # good
       #   Model.distinct.pluck(:id)
       #
-      class UniqBeforePluck < RuboCop::Cop::Cop
+      class UniqBeforePluck < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `distinct` before `pluck`.'
+        RESTRICT_ON_SEND = %i[uniq distinct pluck].freeze
         NEWLINE = "\n"
         PATTERN = '[!^block (send (send %<type>s :pluck ...) ' \
                   '${:uniq :distinct} ...)]'
@@ -69,11 +71,7 @@ module RuboCop
 
           return unless method
 
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node.loc.selector) do |corrector|
             method = node.method_name
 
             corrector.remove(dot_method_with_whitespace(method, node))

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

@@ -24,13 +24,13 @@ module RuboCop
       #   # good - even if the schema does not have a unique index
       #   validates :account, length: { minimum: MIN_LENGTH }
       #
-      class UniqueValidationWithoutIndex < Cop
+      class UniqueValidationWithoutIndex < Base
         include ActiveRecordHelper
 
         MSG = 'Uniqueness validation should be with a unique index.'
+        RESTRICT_ON_SEND = %i[validates].freeze
 
         def on_send(node)
-          return unless node.method?(:validates)
           return unless uniqueness_part(node)
           return if condition_part?(node)
           return unless schema

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

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #   Rails.env.production?
       #   Rails.env == 'production'
-      class UnknownEnv < Cop
+      class UnknownEnv < Base
         MSG = 'Unknown environment `%<name>s`.'
         MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
                       'Did you mean `%<similar>s`?'
@@ -41,7 +41,7 @@ module RuboCop
 
         def on_send(node)
           unknown_environment_predicate?(node) do |name|
-            add_offense(node, location: :selector, message: message(name))
+            add_offense(node.loc.selector, message: message(name))
           end
 
           unknown_environment_equal?(node) do |str_node|
@@ -62,7 +62,7 @@ module RuboCop
           # DidYouMean::SpellChecker is not available in all versions of Ruby,
           # and even on versions where it *is* available (>= 2.3), it is not
           # always required correctly. So we do a feature check first. See:
-          # https://github.com/rubocop-hq/rubocop/issues/7979
+          # https://github.com/rubocop/rubocop/issues/7979
           similar_names = if defined?(DidYouMean::SpellChecker)
                             spell_checker = DidYouMean::SpellChecker.new(dictionary: environments)
                             spell_checker.correct(name)

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

@@ -32,7 +32,9 @@ module RuboCop
       #   validates :foo, size: true
       #   validates :foo, uniqueness: true
       #
-      class Validation < Cop
+      class Validation < Base
+        extend AutoCorrector
+
         MSG = 'Prefer the new style validations `%<prefer>s` over ' \
               '`%<current>s`.'
 
@@ -50,22 +52,20 @@ module RuboCop
           uniqueness
         ].freeze
 
-        DENYLIST = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
+        RESTRICT_ON_SEND = TYPES.map { |p| "validates_#{p}_of".to_sym }.freeze
         ALLOWLIST = TYPES.map { |p| "validates :column, #{p}: value" }.freeze
 
         def on_send(node)
-          return unless !node.receiver && DENYLIST.include?(node.method_name)
+          return if node.receiver
 
-          add_offense(node, location: :selector)
-        end
+          range = node.loc.selector
 
-        def autocorrect(node)
-          last_argument = node.arguments.last
-          return if !last_argument.literal? && !last_argument.splat_type? &&
-                    !frozen_array_argument?(last_argument)
+          add_offense(range, message: message(node)) do |corrector|
+            last_argument = node.arguments.last
+            return if !last_argument.literal? && !last_argument.splat_type? &&
+                      !frozen_array_argument?(last_argument)
 
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, 'validates')
+            corrector.replace(range, 'validates')
             correct_validate_type(corrector, node)
           end
         end
@@ -73,12 +73,13 @@ module RuboCop
         private
 
         def message(node)
-          format(MSG, prefer: preferred_method(node.method_name),
-                      current: node.method_name)
+          method_name = node.method_name
+
+          format(MSG, prefer: preferred_method(method_name), current: method_name)
         end
 
         def preferred_method(method)
-          ALLOWLIST[DENYLIST.index(method.to_sym)]
+          ALLOWLIST[RESTRICT_ON_SEND.index(method.to_sym)]
         end
 
         def correct_validate_type(corrector, node)