rubocop-rails 2.5.1 → 2.8.0

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `collection.exclude?(obj)`
+      # over `!collection.include?(obj)`.
+      #
+      # @example
+      #   # bad
+      #   !array.include?(2)
+      #   !hash.include?(:key)
+      #
+      #   # good
+      #   array.exclude?(2)
+      #   hash.exclude?(:key)
+      #
+      class NegateInclude < Cop
+        MSG = 'Use `.exclude?` and remove the negation part.'
+
+        def_node_matcher :negate_include_call?, <<~PATTERN
+          (send (send $_ :include? $_) :!)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if negate_include_call?(node)
+        end
+
+        def autocorrect(node)
+          negate_include_call?(node) do |receiver, obj|
+            lambda do |corrector|
+              corrector.replace(node, "#{receiver.source}.exclude?(#{obj.source})")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop checks for places where ordering by `id` column is used.
+      #
+      # Don't use the `id` column for ordering. The sequence of ids is not guaranteed
+      # to be in any particular order, despite often (incidentally) being chronological.
+      # Use a timestamp column to order chronologically. As a bonus the intent is clearer.
+      #
+      # NOTE: Make sure the changed order column does not introduce performance
+      # bottlenecks and appropriate database indexes are added.
+      #
+      # @example
+      #   # bad
+      #   scope :chronological, -> { order(id: :asc) }
+      #   scope :chronological, -> { order(primary_key => :asc) }
+      #
+      #   # good
+      #   scope :chronological, -> { order(created_at: :asc) }
+      #
+      class OrderById < Base
+        include RangeHelp
+
+        MSG = 'Do not use the `id` column for ordering. '\
+              'Use a timestamp column to order chronologically.'
+
+        def_node_matcher :order_by_id?, <<~PATTERN
+          (send _ :order
+            {
+              (sym :id)
+              (hash (pair (sym :id) _))
+              (send _ :primary_key)
+              (hash (pair (send _ :primary_key) _))
+            })
+        PATTERN
+
+        def on_send(node)
+          return unless node.method?(:order)
+
+          add_offense(offense_range(node)) if order_by_id?(node)
+        end
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `pick` over `pluck(...).first`.
+      #
+      # Using `pluck` followed by `first` creates an intermediate array, which
+      # `pick` avoids. When called on an Active Record relation, `pick` adds a
+      # limit to the query so that only one value is fetched from the database.
+      #
+      # @example
+      #   # bad
+      #   Model.pluck(:a).first
+      #   [{ a: :b, c: :d }].pluck(:a, :b).first
+      #
+      #   # good
+      #   Model.pick(:a)
+      #   [{ a: :b, c: :d }].pick(:a, :b)
+      class Pick < Cop
+        extend TargetRailsVersion
+
+        MSG = 'Prefer `pick(%<args>s)` over `pluck(%<args>s).first`.'
+
+        minimum_target_rails_version 6.0
+
+        def_node_matcher :pick_candidate?, <<~PATTERN
+          (send (send _ :pluck ...) :first)
+        PATTERN
+
+        def on_send(node)
+          pick_candidate?(node) do
+            range = node.receiver.loc.selector.join(node.loc.selector)
+            add_offense(node, location: range)
+          end
+        end
+
+        def autocorrect(node)
+          first_range = node.receiver.source_range.end.join(node.loc.selector)
+
+          lambda do |corrector|
+            corrector.remove(first_range)
+            corrector.replace(node.receiver.loc.selector, 'pick')
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, args: node.receiver.arguments.map(&:source).join(', '))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `pluck` over `map`.
+      #
+      # `pluck` can be used instead of `map` to extract a single key from each
+      # element in an enumerable. When called on an Active Record relation, it
+      # results in a more efficient query that only selects the necessary key.
+      #
+      # @example
+      #   # bad
+      #   Post.published.map { |post| post[:title] }
+      #   [{ a: :b, c: :d }].collect { |el| el[:a] }
+      #
+      #   # good
+      #   Post.published.pluck(:title)
+      #   [{ a: :b, c: :d }].pluck(:a)
+      class Pluck < Cop
+        extend TargetRailsVersion
+
+        MSG = 'Prefer `pluck(:%<value>s)` over `%<method>s { |%<argument>s| %<element>s[:%<value>s] }`.'
+
+        minimum_target_rails_version 5.0
+
+        def_node_matcher :pluck_candidate?, <<~PATTERN
+          (block (send _ ${:map :collect}) (args (arg $_argument)) (send (lvar $_element) :[] (sym $_value)))
+        PATTERN
+
+        def on_block(node)
+          pluck_candidate?(node) do |method, argument, element, value|
+            next unless argument == element
+
+            add_offense(node, location: offense_range(node), message: message(method, argument, element, value))
+          end
+        end
+
+        def autocorrect(node)
+          _method, _argument, _element, value = pluck_candidate?(node)
+
+          lambda do |corrector|
+            corrector.replace(offense_range(node), "pluck(:#{value})")
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          node.send_node.loc.selector.join(node.loc.end)
+        end
+
+        def message(method, argument, element, value)
+          format(MSG, method: method, argument: argument, element: element, value: value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces the use of `ids` over `pluck(:id)` and `pluck(primary_key)`.
+      #
+      # @example
+      #   # bad
+      #   User.pluck(:id)
+      #   user.posts.pluck(:id)
+      #
+      #   def self.user_ids
+      #     pluck(primary_key)
+      #   end
+      #
+      #   # good
+      #   User.ids
+      #   user.posts.ids
+      #
+      #   def self.user_ids
+      #     ids
+      #   end
+      #
+      class PluckId < Cop
+        include RangeHelp
+        include ActiveRecordHelper
+
+        MSG = 'Use `ids` instead of `%<bad_method>s`.'
+
+        def_node_matcher :pluck_id_call?, <<~PATTERN
+          (send _ :pluck {(sym :id) (send nil? :primary_key)})
+        PATTERN
+
+        def on_send(node)
+          return if !pluck_id_call?(node) || in_where?(node)
+
+          range = offense_range(node)
+          message = format(MSG, bad_method: range.source)
+
+          add_offense(node, location: range, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(offense_range(node), 'ids')
+          end
+        end
+
+        private
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where `pluck` is used in `where` query methods
+      # and can be replaced with `select`.
+      #
+      # Since `pluck` is an eager method and hits the database immediately,
+      # using `select` helps to avoid additional database queries.
+      #
+      # 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) in the `where` is used as offenses.
+      #
+      # When the EnforcedStyle is aggressive then all calls to `pluck` in the
+      # `where` is used as offenses. This may lead to false positives
+      # as the cop cannot replace to `select` between calls to `pluck` on an
+      # `ActiveRecord::Relation` instance vs a call to `pluck` on an `Array` instance.
+      #
+      # @example
+      #   # bad
+      #   Post.where(user_id: User.active.pluck(:id))
+      #
+      #   # good
+      #   Post.where(user_id: User.active.select(:id))
+      #   Post.where(user_id: active_users.select(:id))
+      #
+      # @example EnforcedStyle: conservative (default)
+      #   # good
+      #   Post.where(user_id: active_users.pluck(:id))
+      #
+      # @example EnforcedStyle: aggressive
+      #   # bad
+      #   Post.where(user_id: active_users.pluck(:id))
+      #
+      class PluckInWhere < Cop
+        include ActiveRecordHelper
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `select` instead of `pluck` within `where` query method.'
+
+        def on_send(node)
+          return unless node.method?(:pluck) && in_where?(node)
+          return if style == :conservative && !root_receiver(node)&.const_type?
+
+          add_offense(node, location: :selector)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, 'select')
+          end
+        end
+
+        private
+
+        def root_receiver(node)
+          receiver = node.receiver
+
+          if receiver&.send_type?
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -76,15 +76,11 @@ module RuboCop
           return if ignore_if_node?(node)
 
           redundant_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
+            add_offense(node, message: message(node, receiver, other)) unless ignore_other_node?(other) || receiver.nil?
           end
 
           redundant_negative_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other) || receiver.nil?
-              add_offense(node, message: message(node, receiver, other))
-            end
+            add_offense(node, message: message(node, receiver, other)) unless ignore_other_node?(other) || receiver.nil?
           end
         end
 

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

@@ -41,8 +41,25 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            task_name = node.arguments[0]
+            task_dependency = correct_task_dependency(task_name)
+
+            corrector.replace(task_name.loc.expression, task_dependency)
+          end
+        end
+
         private
 
+        def correct_task_dependency(task_name)
+          if task_name.sym_type?
+            "#{task_name.source.delete(':|\'|"')}: :environment"
+          else
+            "#{task_name.source} => :environment"
+          end
+        end
+
         def task_name(node)
           first_arg = node.arguments[0]
           case first_arg&.type

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop detects cases where the `:foreign_key` option on associations
+      # is redundant.
+      #
+      # @example
+      #   # bad
+      #   class Post
+      #     has_many :comments, foreign_key: 'post_id'
+      #   end
+      #
+      #   class Comment
+      #     belongs_to :post, foreign_key: 'post_id'
+      #   end
+      #
+      #   # good
+      #   class Post
+      #     has_many :comments
+      #   end
+      #
+      #   class Comment
+      #     belongs_to :author, foreign_key: 'user_id'
+      #   end
+      class RedundantForeignKey < Cop
+        include RangeHelp
+
+        MSG = 'Specifying the default value for `foreign_key` is redundant.'
+
+        def_node_matcher :association_with_foreign_key, <<~PATTERN
+          (send nil? ${:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_)
+            $(hash <$(pair (sym :foreign_key) ({sym str} $_)) ...>)
+          )
+        PATTERN
+
+        def on_send(node)
+          association_with_foreign_key(node) do |type, name, options, foreign_key_pair, foreign_key|
+            if redundant?(node, type, name, options, foreign_key)
+              add_offense(node, location: foreign_key_pair.loc.expression)
+            end
+          end
+        end
+
+        def autocorrect(node)
+          _type, _name, _options, foreign_key_pair, _foreign_key = association_with_foreign_key(node)
+          range = range_with_surrounding_space(range: foreign_key_pair.source_range, side: :left)
+          range = range_with_surrounding_comma(range, :left)
+
+          lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def redundant?(node, association_type, association_name, options, foreign_key)
+          foreign_key.to_s == default_foreign_key(node, association_type, association_name, options)
+        end
+
+        def default_foreign_key(node, association_type, association_name, options)
+          if association_type == :belongs_to
+            "#{association_name}_id"
+          elsif (as = find_as_option(options))
+            "#{as}_id"
+          else
+            node.parent_module_name&.foreign_key
+          end
+        end
+
+        def find_as_option(options)
+          options.pairs.find do |pair|
+            pair.key.sym_type? && pair.key.value == :as
+          end&.value&.value
+        end
+      end
+    end
+  end
+end