rubocop-rails 2.8.0 → 2.10.1

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

@@ -19,7 +19,7 @@ module RuboCop
       #
       #   # bad
       #   Time.now
-      #   Time.parse('2015-03-02 19:05:37')
+      #   Time.parse('2015-03-02T19:05:37')
       #
       #   # bad
       #   Time.current
@@ -27,24 +27,26 @@ module RuboCop
       #
       #   # good
       #   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`.
       #
       #   # bad
       #   Time.now
-      #   Time.parse('2015-03-02 19:05:37')
+      #   Time.parse('2015-03-02T19:05:37')
       #
       #   # good
       #   Time.zone.now
-      #   Time.zone.parse('2015-03-02 19:05:37')
+      #   Time.zone.parse('2015-03-02T19:05:37')
       #
       #   # 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.'
@@ -62,6 +64,8 @@ module RuboCop
         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 +75,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 +119,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 +131,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 +202,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 behaviour at a later time.
+      # Using `Time.use_zone` ensures the code passed in 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 blocks 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
@@ -46,6 +46,8 @@ module RuboCop
 
         def find_schema_information(node)
           klass = class_node(node)
+          return unless klass
+
           table = schema.table_by(name: table_name(klass))
           names = column_names(node)
 

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/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)

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where manually constructed SQL
+      # in `where` can be replaced with `where(attribute: value)`.
+      #
+      # @example
+      #   # bad
+      #   User.where('name = ?', 'Gabe')
+      #   User.where('name = :name', name: 'Gabe')
+      #   User.where('name IS NULL')
+      #   User.where('name IN (?)', ['john', 'jane'])
+      #   User.where('name IN (:names)', names: ['john', 'jane'])
+      #   User.where('users.name = :name', name: 'Gabe')
+      #
+      #   # good
+      #   User.where(name: 'Gabe')
+      #   User.where(name: nil)
+      #   User.where(name: ['john', 'jane'])
+      #   User.where(users: { name: 'Gabe' })
+      class WhereEquals < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of manually constructing SQL.'
+        RESTRICT_ON_SEND = %i[where].freeze
+
+        def_node_matcher :where_method_call?, <<~PATTERN
+          {
+            (send _ :where (array $str_type? $_ ?))
+            (send _ :where $str_type? $_ ?)
+          }
+        PATTERN
+
+        def on_send(node)
+          where_method_call?(node) do |template_node, value_node|
+            value_node = value_node.first
+
+            range = offense_range(node)
+
+            column_and_value = extract_column_and_value(template_node, value_node)
+            return unless column_and_value
+
+            good_method = build_good_method(*column_and_value)
+            message = format(MSG, good_method: good_method)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, good_method)
+            end
+          end
+        end
+
+        EQ_ANONYMOUS_RE = /\A([\w.]+)\s+=\s+\?\z/.freeze             # column = ?
+        IN_ANONYMOUS_RE = /\A([\w.]+)\s+IN\s+\(\?\)\z/i.freeze       # column IN (?)
+        EQ_NAMED_RE     = /\A([\w.]+)\s+=\s+:(\w+)\z/.freeze         # column = :column
+        IN_NAMED_RE     = /\A([\w.]+)\s+IN\s+\(:(\w+)\)\z/i.freeze   # column IN (:column)
+        IS_NULL_RE      = /\A([\w.]+)\s+IS\s+NULL\z/i.freeze         # column IS NULL
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+
+        def extract_column_and_value(template_node, value_node)
+          value =
+            case template_node.value
+            when EQ_ANONYMOUS_RE, IN_ANONYMOUS_RE
+              value_node.source
+            when EQ_NAMED_RE, IN_NAMED_RE
+              return unless value_node&.hash_type?
+
+              pair = value_node.pairs.find { |p| p.key.value.to_sym == Regexp.last_match(2).to_sym }
+              pair.value.source
+            when IS_NULL_RE
+              'nil'
+            else
+              return
+            end
+
+          [Regexp.last_match(1), value]
+        end
+
+        def build_good_method(column, value)
+          if column.include?('.')
+            table, column = column.split('.')
+
+            "where(#{table}: { #{column}: #{value} })"
+          else
+            "where(#{column}: #{value})"
+          end
+        end
+      end
+    end
+  end
+end