rubocop-rails 2.5.0 → 2.7.1

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

@@ -85,9 +85,7 @@ module RuboCop
             end
 
             # prefer `Time` over `DateTime` class
-            if strict?
-              corrector.replace(node.children.first.source_range, 'Time')
-            end
+            corrector.replace(node.children.first.source_range, 'Time') if strict?
             remove_redundant_in_time_zone(corrector, node)
           end
         end

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

@@ -3,19 +3,20 @@
 module RuboCop
   module Cop
     module Rails
-      # Prefer the use of uniq (or distinct), before pluck instead of after.
+      # Prefer the use of distinct, before pluck instead of after.
       #
-      # The use of uniq before pluck is preferred because it executes within
+      # The use of distinct before pluck is preferred because it executes within
       # 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.
+      # (i.e. a model class) before distinct 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.
+      # 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.
@@ -25,7 +26,7 @@ module RuboCop
       #   Model.pluck(:id).uniq
       #
       #   # good
-      #   Model.uniq.pluck(:id)
+      #   Model.distinct.pluck(:id)
       #
       # @example EnforcedStyle: aggressive
       #   # bad
@@ -40,13 +41,13 @@ module RuboCop
       #   Model.pluck(:id).uniq
       #
       #   # good
-      #   Model.uniq.pluck(:id)
+      #   Model.distinct.pluck(:id)
       #
       class UniqBeforePluck < RuboCop::Cop::Cop
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG = 'Use `%<method>s` before `pluck`.'
+        MSG = 'Use `distinct` before `pluck`.'
         NEWLINE = "\n"
         PATTERN = '[!^block (send (send %<type>s :pluck ...) ' \
                   '${:uniq :distinct} ...)]'
@@ -66,8 +67,7 @@ module RuboCop
 
           return unless method
 
-          add_offense(node, location: :selector,
-                            message: format(MSG, method: method))
+          add_offense(node, location: :selector)
         end
 
         def autocorrect(node)
@@ -75,7 +75,7 @@ module RuboCop
             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
 

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

@@ -32,6 +32,7 @@ module RuboCop
         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)
 
@@ -50,8 +51,21 @@ module RuboCop
           names = column_names(node)
           return true unless names
 
-          table.indices.any? do |index|
-            index.unique && index.columns.to_set == names
+          # Compatibility for Rails 4.2.
+          add_indicies = schema.add_indicies_by(table_name: table_name(klass))
+
+          (table.indices + add_indicies).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
 
@@ -113,6 +127,18 @@ module RuboCop
           end
         end
 
+        def condition_part?(node)
+          pairs = node.arguments.last
+          return unless pairs.hash_type?
+
+          pairs.each_pair.any? do |pair|
+            key = pair.key
+            next unless key.sym_type?
+
+            key.value == :if || key.value == :unless
+          end
+        end
+
         def array_node_to_array(node)
           node.values.map do |elm|
             case elm.type
@@ -123,10 +149,6 @@ module RuboCop
             end
           end
         end
-
-        def schema
-          RuboCop::Rails::SchemaLoader.load(target_ruby_version)
-        end
       end
     end
   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
@@ -15,8 +18,6 @@ module RuboCop
       #   Rails.env.production?
       #   Rails.env == 'production'
       class UnknownEnv < Cop
-        include NameSimilarity
-
         MSG = 'Unknown environment `%<name>s`.'
         MSG_SIMILAR = 'Unknown environment `%<name>s`. ' \
                       'Did you mean `%<similar>s`?'
@@ -57,11 +58,22 @@ module RuboCop
 
         def message(name)
           name = name.to_s.chomp('?')
-          similar = find_similar_name(name, [])
-          if similar
-            format(MSG_SIMILAR, name: name, similar: similar)
-          else
+
+          # 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)
+          else
+            format(MSG_SIMILAR, name: name, similar: similar_names.join(', '))
           end
         end
 

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `exists?(...)` over `where(...).exists?`.
+      #
+      # @example
+      #   # bad
+      #   User.where(name: 'john').exists?
+      #   User.where(['name = ?', 'john']).exists?
+      #   User.where('name = ?', 'john').exists?
+      #   user.posts.where(published: true).exists?
+      #
+      #   # good
+      #   User.exists?(name: 'john')
+      #   User.where('length(name) > 10').exists?
+      #   user.posts.exists?(published: true)
+      #
+      class WhereExists < Cop
+        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
+
+        def_node_matcher :where_exists_call?, <<~PATTERN
+          (send (send _ :where $...) :exists?)
+        PATTERN
+
+        def on_send(node)
+          where_exists_call?(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)
+          end
+        end
+
+        def autocorrect(node)
+          args = where_exists_call?(node)
+
+          lambda do |corrector|
+            corrector.replace(
+              correction_range(node),
+              build_good_method(args)
+            )
+          end
+        end
+
+        private
+
+        def convertable_args?(args)
+          args.size > 1 || args[0].hash_type? || args[0].array_type?
+        end
+
+        def correction_range(node)
+          node.receiver.loc.selector.join(node.loc.selector)
+        end
+
+        def build_good_method(args)
+          if args.size > 1
+            "exists?([#{args.map(&:source).join(', ')}])"
+          else
+            "exists?(#{args[0].source})"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -6,6 +6,7 @@ require_relative 'mixin/target_rails_version'
 
 require_relative 'rails/action_filter'
 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/application_controller'
@@ -16,8 +17,10 @@ require_relative 'rails/assert_not'
 require_relative 'rails/belongs_to'
 require_relative 'rails/blank'
 require_relative 'rails/bulk_change_table'
+require_relative 'rails/content_tag'
 require_relative 'rails/create_table_with_timestamps'
 require_relative 'rails/date'
+require_relative 'rails/default_scope'
 require_relative 'rails/delegate'
 require_relative 'rails/delegate_allow_blank'
 require_relative 'rails/dynamic_find_by'
@@ -27,6 +30,7 @@ require_relative 'rails/environment_comparison'
 require_relative 'rails/exit'
 require_relative 'rails/file_path'
 require_relative 'rails/find_by'
+require_relative 'rails/find_by_id'
 require_relative 'rails/find_each'
 require_relative 'rails/has_and_belongs_to_many'
 require_relative 'rails/has_many_or_has_one_dependent'
@@ -36,31 +40,44 @@ require_relative 'rails/http_status'
 require_relative 'rails/ignored_skip_action_filter_option'
 require_relative 'rails/index_by'
 require_relative 'rails/index_with'
+require_relative 'rails/inquiry'
 require_relative 'rails/inverse_of'
 require_relative 'rails/lexically_scoped_action_filter'
 require_relative 'rails/link_to_blank'
+require_relative 'rails/mailer_name'
+require_relative 'rails/match_route'
+require_relative 'rails/negate_include'
 require_relative 'rails/not_null_column'
 require_relative 'rails/output'
 require_relative 'rails/output_safety'
+require_relative 'rails/pick'
+require_relative 'rails/pluck'
+require_relative 'rails/pluck_id'
+require_relative 'rails/pluck_in_where'
 require_relative 'rails/pluralization_grammar'
 require_relative 'rails/presence'
 require_relative 'rails/present'
 require_relative 'rails/rake_environment'
 require_relative 'rails/read_write_attribute'
 require_relative 'rails/redundant_allow_nil'
+require_relative 'rails/redundant_foreign_key'
 require_relative 'rails/redundant_receiver_in_with_options'
 require_relative 'rails/reflection_class_name'
 require_relative 'rails/refute_methods'
 require_relative 'rails/relative_date_constant'
+require_relative 'rails/render_inline'
+require_relative 'rails/render_plain_text'
 require_relative 'rails/request_referer'
 require_relative 'rails/reversible_migration'
 require_relative 'rails/safe_navigation'
 require_relative 'rails/safe_navigation_with_blank'
 require_relative 'rails/save_bang'
 require_relative 'rails/scope_args'
+require_relative 'rails/short_i18n'
 require_relative 'rails/skips_model_validations'
 require_relative 'rails/time_zone'
 require_relative 'rails/uniq_before_pluck'
 require_relative 'rails/unique_validation_without_index'
 require_relative 'rails/unknown_env'
 require_relative 'rails/validation'
+require_relative 'rails/where_exists'

data/lib/rubocop/rails/schema_loader.rb

@@ -24,16 +24,6 @@ module RuboCop
         remove_instance_variable(:@schema)
       end
 
-      private
-
-      def load!(target_ruby_version)
-        path = db_schema_path
-        return unless path
-
-        ast = parse(path, target_ruby_version)
-        Schema.new(ast)
-      end
-
       def db_schema_path
         path = Pathname.pwd
         until path.root?
@@ -46,6 +36,16 @@ module RuboCop
         nil
       end
 
+      private
+
+      def load!(target_ruby_version)
+        path = db_schema_path
+        return unless path
+
+        ast = parse(path, target_ruby_version)
+        Schema.new(ast)
+      end
+
       def parse(path, target_ruby_version)
         klass_name = :"Ruby#{target_ruby_version.to_s.sub('.', '')}"
         klass = ::Parser.const_get(klass_name)

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

@@ -5,10 +5,12 @@ module RuboCop
     module SchemaLoader
       # Represent db/schema.rb
       class Schema
-        attr_reader :tables
+        attr_reader :tables, :add_indicies
 
         def initialize(ast)
           @tables = []
+          @add_indicies = []
+
           build!(ast)
         end
 
@@ -18,6 +20,12 @@ module RuboCop
           end
         end
 
+        def add_indicies_by(table_name:)
+          add_indicies.select do |add_index|
+            add_index.table_name == table_name
+          end
+        end
+
         private
 
         def build!(ast)
@@ -26,6 +34,11 @@ module RuboCop
           each_table(ast) do |table_def|
             @tables << Table.new(table_def)
           end
+
+          # Compatibility for Rails 4.2.
+          each_add_index(ast) do |add_index_def|
+            @add_indicies << AddIndex.new(add_index_def)
+          end
         end
 
         def each_table(ast)
@@ -40,9 +53,17 @@ module RuboCop
             yield ast.body
           end
         end
+
+        def each_add_index(ast)
+          ast.body.children.each do |node|
+            next if !node&.send_type? || !node.method?(:add_index)
+
+            yield(node)
+          end
+        end
       end
 
-      # Reprecent a table
+      # Represent a table
       class Table
         attr_reader :name, :columns, :indices
 
@@ -60,7 +81,7 @@ module RuboCop
 
         def build_columns(node)
           each_content(node).map do |child|
-            next unless child.send_type?
+            next unless child&.send_type?
             next if child.method?(:index)
 
             Column.new(child)
@@ -69,7 +90,7 @@ module RuboCop
 
         def build_indices(node)
           each_content(node).map do |child|
-            next unless child.send_type?
+            next unless child&.send_type?
             next unless child.method?(:index)
 
             Index.new(child)
@@ -79,7 +100,7 @@ module RuboCop
         def each_content(node)
           return enum_for(__method__, node) unless block_given?
 
-          case node.body.type
+          case node.body&.type
           when :begin
             node.body.children.each do |child|
               yield(child)
@@ -90,7 +111,7 @@ module RuboCop
         end
       end
 
-      # Reprecent a column
+      # Represent a column
       class Column
         attr_reader :name, :type, :not_null
 
@@ -116,13 +137,12 @@ module RuboCop
         end
       end
 
-      # Reprecent an index
+      # Represent an index
       class Index
         attr_reader :name, :columns, :expression, :unique
 
         def initialize(node)
-          node.first_argument
-          @columns, @expression = build_columns_or_expr(node)
+          @columns, @expression = build_columns_or_expr(node.first_argument)
           @unique = nil
 
           analyze_keywords!(node)
@@ -130,12 +150,11 @@ module RuboCop
 
         private
 
-        def build_columns_or_expr(node)
-          arg = node.first_argument
-          if arg.array_type?
-            [arg.values.map(&:value), nil]
+        def build_columns_or_expr(columns)
+          if columns.array_type?
+            [columns.values.map(&:value), nil]
           else
-            [[], arg.value]
+            [[], columns.value]
           end
         end
 
@@ -153,6 +172,21 @@ module RuboCop
           end
         end
       end
+
+      # Represent an `add_index`
+      class AddIndex < Index
+        attr_reader :table_name
+
+        def initialize(node)
+          super(node)
+
+          @table_name = node.first_argument.value
+          @columns, @expression = build_columns_or_expr(node.arguments[1])
+          @unique = nil
+
+          analyze_keywords!(node)
+        end
+      end
     end
   end
 end