rubocop-rails 2.7.0 → 2.9.1

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

@@ -43,8 +43,9 @@ module RuboCop
       #   # 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.'
@@ -71,26 +72,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?
@@ -128,7 +127,9 @@ 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 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/uniq_before_pluck.rb

@@ -18,6 +18,8 @@ module RuboCop
       # ActiveRecord::Relation vs a call to pluck on an
       # ActiveRecord::Associations::CollectionProxy.
       #
+      # This cop is unsafe because the behavior may change depending on the
+      # database collation.
       # Autocorrect is disabled by default for this cop since it may generate
       # false positives.
       #
@@ -43,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} ...)]'
@@ -67,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,33 +24,37 @@ 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
-          return if with_index?(node)
+
+          klass, table, names = find_schema_information(node)
+          return unless names
+          return if with_index?(klass, table, names)
 
           add_offense(node)
         end
 
         private
 
-        def with_index?(node)
+        def find_schema_information(node)
           klass = class_node(node)
-          return true unless klass # Skip analysis
+          return unless klass
 
           table = schema.table_by(name: table_name(klass))
-          return true unless table # Skip analysis if it can't find the table
-
           names = column_names(node)
-          return true unless names
 
+          [klass, table, names]
+        end
+
+        def with_index?(klass, table, names)
           # Compatibility for Rails 4.2.
           add_indicies = schema.add_indicies_by(table_name: table_name(klass))
 
@@ -95,6 +99,8 @@ module RuboCop
           scope = find_scope(uniq)
           return unless scope
 
+          scope = unfreeze_scope(scope)
+
           case scope.type
           when :sym, :str
             [scope.value]
@@ -112,6 +118,10 @@ module RuboCop
           end
         end
 
+        def unfreeze_scope(scope)
+          scope.send_type? && scope.method?(:freeze) ? scope.children.first : scope
+        end
+
         def class_node(node)
           node.each_ancestor.find(&:class_type?)
         end

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

@@ -5,6 +5,9 @@ module RuboCop
     module Rails
       # This cop checks that environments called with `Rails.env` predicates
       # exist.
+      # By default the cop allows three environments which Rails ships with:
+      # `development`, `test`, and `production`.
+      # More can be added to the `Environments` config parameter.
       #
       # @example
       #   # bad
@@ -14,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`?'
@@ -38,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|
@@ -56,8 +59,16 @@ module RuboCop
         def message(name)
           name = name.to_s.chomp('?')
 
-          spell_checker = DidYouMean::SpellChecker.new(dictionary: environments)
-          similar_names = spell_checker.correct(name)
+          # 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
+          similar_names = if defined?(DidYouMean::SpellChecker)
+                            spell_checker = DidYouMean::SpellChecker.new(dictionary: environments)
+                            spell_checker.correct(name)
+                          else
+                            []
+                          end
 
           if similar_names.empty?
             format(MSG, name: 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

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

@@ -3,9 +3,15 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the use of `exists?(...)` over `where(...).exists?`.
+      # This cop enforces consistent style when using `exists?`.
       #
-      # @example
+      # Two styles are supported for this cop. When EnforcedStyle is 'exists'
+      # then the cop enforces `exists?(...)` over `where(...).exists?`.
+      #
+      # When EnforcedStyle is 'where' then the cop enforces
+      # `where(...).exists?` over `exists?(...)`.
+      #
+      # @example EnforcedStyle: exists (default)
       #   # bad
       #   User.where(name: 'john').exists?
       #   User.where(['name = ?', 'john']).exists?
@@ -17,51 +23,103 @@ module RuboCop
       #   User.where('length(name) > 10').exists?
       #   user.posts.exists?(published: true)
       #
-      class WhereExists < Cop
+      # @example EnforcedStyle: where
+      #   # bad
+      #   User.exists?(name: 'john')
+      #   User.exists?(['name = ?', 'john'])
+      #   User.exists?('name = ?', 'john')
+      #   user.posts.exists?(published: true)
+      #
+      #   # good
+      #   User.where(name: 'john').exists?
+      #   User.where(['name = ?', 'john']).exists?
+      #   User.where('name = ?', 'john').exists?
+      #   user.posts.where(published: true).exists?
+      #   User.where('length(name) > 10').exists?
+      class WhereExists < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
         MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[exists?].freeze
 
         def_node_matcher :where_exists_call?, <<~PATTERN
           (send (send _ :where $...) :exists?)
         PATTERN
 
+        def_node_matcher :exists_with_args?, <<~PATTERN
+          (send _ :exists? $...)
+        PATTERN
+
         def on_send(node)
-          where_exists_call?(node) do |args|
+          find_offenses(node) do |args|
             return unless convertable_args?(args)
 
             range = correction_range(node)
-            message = format(MSG, good_method: build_good_method(args), bad_method: range.source)
-            add_offense(node, location: range, message: message)
+            good_method = build_good_method(args)
+            message = format(MSG, good_method: good_method, bad_method: range.source)
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, good_method)
+            end
           end
         end
 
-        def autocorrect(node)
-          args = where_exists_call?(node)
+        private
 
-          lambda do |corrector|
-            corrector.replace(
-              correction_range(node),
-              build_good_method(args)
-            )
-          end
+        def where_style?
+          style == :where
         end
 
-        private
+        def exists_style?
+          style == :exists
+        end
+
+        def find_offenses(node, &block)
+          if exists_style?
+            where_exists_call?(node, &block)
+          elsif where_style?
+            exists_with_args?(node, &block)
+          end
+        end
 
         def convertable_args?(args)
+          return false if args.empty?
+
           args.size > 1 || args[0].hash_type? || args[0].array_type?
         end
 
         def correction_range(node)
-          node.receiver.loc.selector.join(node.loc.selector)
+          if exists_style?
+            node.receiver.loc.selector.join(node.loc.selector)
+          elsif where_style?
+            node.loc.selector.with(end_pos: node.loc.expression.end_pos)
+          end
         end
 
         def build_good_method(args)
+          if exists_style?
+            build_good_method_exists(args)
+          elsif where_style?
+            build_good_method_where(args)
+          end
+        end
+
+        def build_good_method_exists(args)
           if args.size > 1
             "exists?([#{args.map(&:source).join(', ')}])"
           else
             "exists?(#{args[0].source})"
           end
         end
+
+        def build_good_method_where(args)
+          if args.size > 1
+            "where(#{args.map(&:source).join(', ')}).exists?"
+          else
+            "where(#{args[0].source}).exists?"
+          end
+        end
       end
     end
   end