rubocop-rails 2.0.1 → 2.19.1

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

@@ -3,91 +3,82 @@
 module RuboCop
   module Cop
     module Rails
-      # Prefer the use of uniq (or distinct), before pluck instead of after.
+      # Prefer using `distinct` before `pluck` instead of `uniq` after `pluck`.
       #
-      # The use of uniq before pluck is preferred because it executes within
+      # The use of distinct before pluck is preferred because it executes by
       # the database.
       #
       # This cop has two different enforcement modes. When the EnforcedStyle
-      # is conservative (the default) then only calls to pluck on a constant
-      # (i.e. a model class) before uniq are added as offenses.
+      # is `conservative` (the default), then only calls to `pluck` on a constant
+      # (i.e. a model class) before `uniq` are added as offenses.
       #
-      # When the EnforcedStyle is aggressive then all calls to pluck before
-      # uniq are added as offenses. This may lead to false positives as the cop
-      # cannot distinguish between calls to pluck on an ActiveRecord::Relation
-      # vs a call to pluck on an ActiveRecord::Associations::CollectionProxy.
+      # When the EnforcedStyle is `aggressive` then all calls to `pluck` before
+      # distinct are added as offenses. This may lead to false positives
+      # as the cop cannot distinguish between calls to `pluck` on an
+      # ActiveRecord::Relation vs a call to pluck on an
+      # ActiveRecord::Associations::CollectionProxy.
       #
-      # Autocorrect is disabled by default for this cop since it may generate
-      # false positives.
+      # @safety
+      #   This cop is unsafe for autocorrection because the behavior may change
+      #   depending on the database collation.
       #
       # @example EnforcedStyle: conservative (default)
-      #   # bad
-      #   Model.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.pluck(:band_name).uniq
       #
       #   # good
-      #   Model.uniq.pluck(:id)
+      #   Album.distinct.pluck(:band_name)
       #
       # @example EnforcedStyle: aggressive
-      #   # bad
-      #   # this will return a Relation that pluck is called on
-      #   Model.where(cond: true).pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.pluck(:band_name).uniq
       #
-      #   # bad
-      #   # an association on an instance will return a CollectionProxy
-      #   instance.assoc.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   Album.where(year: 1985).pluck(:band_name).uniq
       #
-      #   # bad
-      #   Model.pluck(:id).uniq
+      #   # bad - redundantly fetches duplicate values
+      #   customer.favourites.pluck(:color).uniq
       #
       #   # good
-      #   Model.uniq.pluck(:id)
+      #   Album.distinct.pluck(:band_name)
+      #   Album.distinct.where(year: 1985).pluck(:band_name)
+      #   customer.favourites.distinct.pluck(:color)
       #
-      class UniqBeforePluck < RuboCop::Cop::Cop
+      class UniqBeforePluck < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Use `%<method>s` before `pluck`.'
+        MSG = 'Use `distinct` before `pluck`.'
+        RESTRICT_ON_SEND = %i[uniq].freeze
         NEWLINE = "\n"
-        PATTERN = '[!^block (send (send %<type>s :pluck ...) ' \
-                  '${:uniq :distinct} ...)]'
+        PATTERN = '[!^block (send (send %<type>s :pluck ...) :uniq ...)]'
 
-        def_node_matcher :conservative_node_match,
-                         format(PATTERN, type: 'const')
+        def_node_matcher :conservative_node_match, format(PATTERN, type: 'const')
 
-        def_node_matcher :aggressive_node_match,
-                         format(PATTERN, type: '_')
+        def_node_matcher :aggressive_node_match, format(PATTERN, type: '_')
 
         def on_send(node)
-          method = if style == :conservative
-                     conservative_node_match(node)
-                   else
-                     aggressive_node_match(node)
-                   end
+          uniq = if style == :conservative
+                   conservative_node_match(node)
+                 else
+                   aggressive_node_match(node)
+                 end
 
-          return unless method
+          return unless uniq
 
-          add_offense(node, location: :selector,
-                            message: format(MSG, method: method))
-        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))
-            corrector.insert_before(node.receiver.loc.dot.begin, ".#{method}")
+            corrector.insert_before(node.receiver.loc.dot.begin, '.distinct')
           end
         end
 
         private
 
-        def style_parameter_name
-          'EnforcedStyle'
-        end
-
         def dot_method_with_whitespace(method, node)
-          range_between(dot_method_begin_pos(method, node),
-                        node.loc.selector.end_pos)
+          range_between(dot_method_begin_pos(method, node), node.loc.selector.end_pos)
         end
 
         def dot_method_begin_pos(method, node)

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

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # When you define a uniqueness validation in Active Record model,
+      # you also should add a unique index for the column. There are two reasons.
+      # First, duplicated records may occur even if Active Record's validation
+      # is defined.
+      # Second, it will cause slow queries. The validation executes a `SELECT`
+      # statement with the target column when inserting/updating a record.
+      # If the column does not have an index and the table is large,
+      # the query will be heavy.
+      #
+      # Note that the cop does nothing if db/schema.rb does not exist.
+      #
+      # @example
+      #   # bad - if the schema does not have a unique index
+      #   validates :account, uniqueness: true
+      #
+      #   # good - if the schema has a unique index
+      #   validates :account, uniqueness: true
+      #
+      #   # good - even if the schema does not have a unique index
+      #   validates :account, length: { minimum: MIN_LENGTH }
+      #
+      class UniqueValidationWithoutIndex < Base
+        include ActiveRecordHelper
+
+        MSG = 'Uniqueness validation should have a unique index on the database column.'
+        RESTRICT_ON_SEND = %i[validates].freeze
+
+        def on_send(node)
+          return unless uniqueness_part(node)
+          return if condition_part?(node)
+          return unless schema
+
+          klass, table, names = find_schema_information(node)
+          return unless names
+          return if with_index?(klass, table, names)
+
+          add_offense(node)
+        end
+
+        private
+
+        def find_schema_information(node)
+          klass = class_node(node)
+          return unless klass
+
+          table = schema.table_by(name: table_name(klass))
+          names = column_names(node)
+
+          [klass, table, names]
+        end
+
+        def with_index?(klass, table, names)
+          # Compatibility for Rails 4.2.
+          add_indices = schema.add_indices_by(table_name: table_name(klass))
+
+          (table.indices + add_indices).any? do |index|
+            index.unique && (index.columns.to_set == names || include_column_names_in_expression_index?(index, names))
+          end
+        end
+
+        def include_column_names_in_expression_index?(index, column_names)
+          return false unless (expression_index = index.expression)
+
+          column_names.all? do |column_name|
+            expression_index.include?(column_name)
+          end
+        end
+
+        def column_names(node)
+          arg = node.first_argument
+          return unless arg.str_type? || arg.sym_type?
+
+          ret = [arg.value]
+          names_from_scope = column_names_from_scope(node)
+          ret.concat(names_from_scope) if names_from_scope
+
+          ret = ret.flat_map do |name|
+            klass = class_node(node)
+            resolve_relation_into_column(
+              name: name.to_s,
+              class_node: klass,
+              table: schema.table_by(name: table_name(klass))
+            )
+          end
+          ret.include?(nil) ? nil : ret.to_set
+        end
+
+        def column_names_from_scope(node)
+          uniq = uniqueness_part(node)
+          return unless uniq.hash_type?
+
+          scope = find_scope(uniq)
+          return unless scope
+
+          scope = unfreeze_scope(scope)
+
+          case scope.type
+          when :sym, :str
+            [scope.value]
+          when :array
+            array_node_to_array(scope)
+          end
+        end
+
+        def find_scope(pairs)
+          pairs.each_pair.find do |pair|
+            key = pair.key
+            next unless key.sym_type? && key.value == :scope
+
+            break pair.value
+          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
+
+        def uniqueness_part(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair.find do |pair|
+            next unless pair.key.sym_type? && pair.key.value == :uniqueness
+
+            break pair.value
+          end
+        end
+
+        def condition_part?(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          return true if condition_hash_part?(pairs, keys: %i[if unless])
+
+          uniqueness_node = uniqueness_part(node)
+          return unless uniqueness_node&.hash_type?
+
+          condition_hash_part?(uniqueness_node, keys: %i[if unless conditions])
+        end
+
+        def condition_hash_part?(pairs, keys:)
+          pairs.each_pair.any? do |pair|
+            key = pair.key
+            next unless key.sym_type?
+
+            keys.include?(key.value)
+          end
+        end
+
+        def array_node_to_array(node)
+          node.values.map do |elm|
+            case elm.type
+            when :str, :sym
+              elm.value
+            else
+              return nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,55 +3,86 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that environments called with `Rails.env` predicates
+      # 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
       #   Rails.env.proudction?
+      #   Rails.env == 'proudction'
       #
       #   # good
       #   Rails.env.production?
-      class UnknownEnv < Cop
-        include NameSimilarity
-
+      #   Rails.env == 'production'
+      class UnknownEnv < Base
         MSG = 'Unknown environment `%<name>s`.'
-        MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
-                      'Did you mean `%<similar>s`?'
+        MSG_SIMILAR = 'Unknown environment `%<name>s`. Did you mean `%<similar>s`?'
 
-        def_node_matcher :unknown_environment?, <<-PATTERN
+        def_node_matcher :rails_env?, <<~PATTERN
           (send
-            (send
-              {(const nil? :Rails) (const (cbase) :Rails)}
-              :env)
-            $#unknown_env_name?)
+            {(const nil? :Rails) (const (cbase) :Rails)}
+            :env)
+        PATTERN
+
+        def_node_matcher :unknown_environment_predicate?, <<~PATTERN
+          (send #rails_env? $#unknown_env_predicate?)
+        PATTERN
+
+        def_node_matcher :unknown_environment_equal?, <<~PATTERN
+          {
+            (send #rails_env? {:== :===} $(str #unknown_env_name?))
+            (send $(str #unknown_env_name?) {:== :===} #rails_env?)
+          }
         PATTERN
 
         def on_send(node)
-          unknown_environment?(node) do |name|
-            add_offense(node, location: :selector, message: message(name))
+          unknown_environment_predicate?(node) do |name|
+            add_offense(node.loc.selector, message: message(name))
+          end
+
+          unknown_environment_equal?(node) do |str_node|
+            name = str_node.value
+            add_offense(str_node, message: message(name))
           end
         end
 
         private
 
         def collect_variable_like_names(_scope)
-          environments.map { |env| env + '?' }
+          environments
         end
 
         def message(name)
-          similar = find_similar_name(name.to_s, [])
-          if similar
-            format(MSG_SIMILAR, name: name, similar: similar)
-          else
+          name = name.to_s.chomp('?')
+
+          # 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/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)
+          else
+            format(MSG_SIMILAR, name: name, similar: similar_names.join(', '))
           end
         end
 
-        def unknown_env_name?(name)
+        def unknown_env_predicate?(name)
           name = name.to_s
-          name.end_with?('?') &&
-            !environments.include?(name[0..-2])
+          name.end_with?('?') && !environments.include?(name[0..-2])
+        end
+
+        def unknown_env_name?(name)
+          !environments.include?(name)
         end
 
         def environments

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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 :appended_ignored_columns, <<~PATTERN
+          (op-asgn (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) || appended_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
+        alias on_op_asgn on_send
+
+        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)
+          return unless klass
+
+          schema.table_by(name: table_name(klass))
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of old-style attribute validation macros.
+      # Checks for the use of old-style attribute validation macros.
       #
       # @example
       #   # bad
@@ -32,9 +32,10 @@ module RuboCop
       #   validates :foo, size: true
       #   validates :foo, uniqueness: true
       #
-      class Validation < Cop
-        MSG = 'Prefer the new style validations `%<prefer>s` over ' \
-              '`%<current>s`.'
+      class Validation < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer the new style validations `%<prefer>s` over `%<current>s`.'
 
         TYPES = %w[
           acceptance
@@ -50,21 +51,19 @@ 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?
+          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
@@ -72,28 +71,60 @@ 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)
-          last_argument = node.arguments.last
-          validate_type = node.method_name.to_s.split('_')[1]
+          last_argument = node.last_argument
 
           if last_argument.hash_type?
-            corrector.replace(
-              last_argument.loc.expression,
-              "#{validate_type}: #{braced_options(last_argument)}"
-            )
+            correct_validate_type_for_hash(corrector, node, last_argument)
+          elsif last_argument.array_type?
+            loc = last_argument.loc
+
+            correct_validate_type_for_array(corrector, node, last_argument, loc)
+          elsif frozen_array_argument?(last_argument)
+            arguments = node.last_argument.receiver
+            loc = arguments.parent.loc
+
+            correct_validate_type_for_array(corrector, node, arguments, loc)
           else
             range = last_argument.source_range
 
-            corrector.insert_after(range, ", #{validate_type}: true")
+            corrector.insert_after(range, ", #{validate_type(node)}: true")
+          end
+        end
+
+        def correct_validate_type_for_hash(corrector, node, arguments)
+          corrector.replace(arguments, "#{validate_type(node)}: #{braced_options(arguments)}")
+        end
+
+        def correct_validate_type_for_array(corrector, node, arguments, loc)
+          attributes = []
+
+          arguments.each_child_node do |child_node|
+            attributes << if arguments.percent_literal?
+                            ":#{child_node.source}"
+                          else
+                            child_node.source
+                          end
           end
+
+          corrector.replace(loc.expression, "#{attributes.join(', ')}, #{validate_type(node)}: true")
+        end
+
+        def validate_type(node)
+          node.method_name.to_s.split('_')[1]
+        end
+
+        def frozen_array_argument?(argument)
+          argument.send_type? && argument.method?(:freeze)
         end
 
         def braced_options(options)