rubocop-rails 2.6.0 → 2.7.0

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,36 @@
+# 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.
+      #
+      # @example
+      #   # bad
+      #   Post.where(user_id: User.active.pluck(:id))
+      #
+      #   # good
+      #   Post.where(user_id: User.active.select(:id))
+      #
+      class PluckInWhere < Cop
+        include ActiveRecordHelper
+
+        MSG = 'Use `select` instead of `pluck` within `where` query method.'
+
+        def on_send(node)
+          add_offense(node, location: :selector) if node.method?(:pluck) && in_where?(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.loc.selector, 'select')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for inline rendering within controller actions.
+      #
+      # @example
+      #   # bad
+      #   class ProductsController < ApplicationController
+      #     def index
+      #       render inline: "<% products.each do |p| %><p><%= p.name %></p><% end %>", type: :erb
+      #     end
+      #   end
+      #
+      #   # good
+      #   # app/views/products/index.html.erb
+      #   # <% products.each do |p| %>
+      #   #   <p><%= p.name %></p>
+      #   # <% end %>
+      #
+      #   class ProductsController < ApplicationController
+      #     def index
+      #     end
+      #   end
+      #
+      class RenderInline < Cop
+        MSG = 'Prefer using a template over inline rendering.'
+
+        def_node_matcher :render_with_options?, <<~PATTERN
+          (send nil? :render $(hash ...))
+        PATTERN
+
+        def on_send(node)
+          render_with_options?(node) do |options|
+            add_offense(node) if includes_inline_key?(options)
+          end
+        end
+
+        private
+
+        def includes_inline_key?(node)
+          node.keys.find { |key| key.value.to_sym == :inline }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop identifies places where `render text:` can be
+      # replaced with `render plain:`.
+      #
+      # @example
+      #   # bad - explicit MIME type to `text/plain`
+      #   render text: 'Ruby!', content_type: 'text/plain'
+      #
+      #   # good - short and precise
+      #   render plain: 'Ruby!'
+      #
+      #   # good - explicit MIME type not to `text/plain`
+      #   render text: 'Ruby!', content_type: 'text/html'
+      #
+      # @example ContentTypeCompatibility: true (default)
+      #   # good - sets MIME type to `text/html`
+      #   render text: 'Ruby!'
+      #
+      # @example ContentTypeCompatibility: false
+      #   # bad - sets MIME type to `text/html`
+      #   render text: 'Ruby!'
+      #
+      class RenderPlainText < Cop
+        MSG = 'Prefer `render plain:` over `render text:`.'
+
+        def_node_matcher :render_plain_text?, <<~PATTERN
+          (send nil? :render $(hash <$(pair (sym :text) $_) ...>))
+        PATTERN
+
+        def on_send(node)
+          render_plain_text?(node) do |options_node, _option_node, _option_value|
+            content_type_node = find_content_type(options_node)
+            add_offense(node) if compatible_content_type?(content_type_node)
+          end
+        end
+
+        def autocorrect(node)
+          render_plain_text?(node) do |options_node, option_node, option_value|
+            content_type_node = find_content_type(options_node)
+            rest_options = options_node.pairs - [option_node, content_type_node].compact
+
+            lambda do |corrector|
+              corrector.replace(
+                node,
+                replacement(rest_options, option_value)
+              )
+            end
+          end
+        end
+
+        private
+
+        def find_content_type(node)
+          node.pairs.find { |p| p.key.value.to_sym == :content_type }
+        end
+
+        def compatible_content_type?(node)
+          (node && node.value.value == 'text/plain') ||
+            (!node && !cop_config['ContentTypeCompatibility'])
+        end
+
+        def replacement(rest_options, option_value)
+          if rest_options.any?
+            "render plain: #{option_value.source}, #{rest_options.map(&:source).join(', ')}"
+          else
+            "render plain: #{option_value.source}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -48,7 +48,7 @@ module RuboCop
         def on_send(node)
           try_call(node) do |try_method, dispatch|
             return if try_method == :try && !cop_config['ConvertTry']
-            return unless dispatch.sym_type? && dispatch.value =~ /\w+[=!?]?/
+            return unless dispatch.sym_type? && dispatch.value.match?(/\w+[=!?]?/)
 
             add_offense(node, message: format(MSG, try: try_method))
           end

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop enforces that short forms of `I18n` methods are used:
+      # `t` instead of `translate` and `l` instead of `localize`.
+      #
+      # This cop has two different enforcement modes. When the EnforcedStyle
+      # is conservative (the default) then only `I18n.translate` and `I18n.localize`
+      # calls are added as offenses.
+      #
+      # When the EnforcedStyle is aggressive then all `translate` and `localize` calls
+      # without a receiver are added as offenses.
+      #
+      # @example
+      #   # bad
+      #   I18n.translate :key
+      #   I18n.localize Time.now
+      #
+      #   # good
+      #   I18n.t :key
+      #   I18n.l Time.now
+      #
+      # @example EnforcedStyle: conservative (default)
+      #   # good
+      #   translate :key
+      #   localize Time.now
+      #   t :key
+      #   l Time.now
+      #
+      # @example EnforcedStyle: aggressive
+      #   # bad
+      #   translate :key
+      #   localize Time.now
+      #
+      #   # good
+      #   t :key
+      #   l Time.now
+      #
+      class ShortI18n < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+
+        PREFERRED_METHODS = {
+          translate: :t,
+          localize: :l
+        }.freeze
+
+        def_node_matcher :long_i18n?, <<~PATTERN
+          (send {nil? (const nil? :I18n)} ${:translate :localize} ...)
+        PATTERN
+
+        def on_send(node)
+          return if style == :conservative && !node.receiver
+
+          long_i18n?(node) do |method_name|
+            good_method = PREFERRED_METHODS[method_name]
+            message = format(MSG, good_method: good_method, bad_method: method_name)
+
+            add_offense(node, location: :selector, message: message)
+          end
+        end
+
+        def autocorrect(node)
+          long_i18n?(node) do |method_name|
+            lambda do |corrector|
+              corrector.replace(node.loc.selector, PREFERRED_METHODS[method_name])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -42,12 +42,18 @@ module RuboCop
                                     decrement_counter
                                     increment!
                                     increment_counter
+                                    insert
+                                    insert!
+                                    insert_all
+                                    insert_all!
                                     toggle!
                                     update_all
                                     update_attribute
                                     update_column
                                     update_columns
-                                    update_counters].freeze
+                                    update_counters
+                                    upsert
+                                    upsert_all].freeze
 
         def_node_matcher :good_touch?, <<~PATTERN
           {
@@ -56,16 +62,30 @@ module RuboCop
           }
         PATTERN
 
+        def_node_matcher :good_insert?, <<~PATTERN
+          (send _ {:insert :insert!} _ {
+            !(hash ...)
+            (hash <(pair (sym !{:returning :unique_by}) _) ...>)
+          } ...)
+        PATTERN
+
         def on_send(node)
-          return if whitelist.include?(node.method_name.to_s)
-          return unless blacklist.include?(node.method_name.to_s)
+          return if allowed_methods.include?(node.method_name.to_s)
+          return unless forbidden_methods.include?(node.method_name.to_s)
           return if allowed_method?(node)
           return if good_touch?(node)
+          return if good_insert?(node)
 
           add_offense(node, location: :selector)
         end
         alias on_csend on_send
 
+        def initialize(*)
+          super
+          @displayed_allowed_warning = false
+          @displayed_forbidden_warning = false
+        end
+
         private
 
         def message(node)
@@ -77,12 +97,27 @@ module RuboCop
             !node.arguments?
         end
 
-        def blacklist
-          cop_config['Blacklist'] || []
+        def forbidden_methods
+          obsolete_result = cop_config['Blacklist']
+          if obsolete_result
+            warn '`Blacklist` has been renamed to `ForbiddenMethods`.' unless @displayed_forbidden_warning
+            @displayed_forbidden_warning = true
+            return obsolete_result
+          end
+
+          cop_config['ForbiddenMethods'] || []
         end
 
-        def whitelist
-          cop_config['Whitelist'] || []
+        def allowed_methods
+          obsolete_result = cop_config['Whitelist']
+          if obsolete_result
+            warn '`Whitelist` has been renamed to `AllowedMethods`.' unless @displayed_allowed_warning
+            @displayed_allowed_warning = true
+
+            return obsolete_result
+          end
+
+          cop_config['AllowedMethods'] || []
         end
       end
     end

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

@@ -23,7 +23,7 @@ module RuboCop
       #
       # @example EnforcedStyle: conservative (default)
       #   # bad
-      #   Model.pluck(:id).distinct
+      #   Model.pluck(:id).uniq
       #
       #   # good
       #   Model.distinct.pluck(:id)
@@ -31,14 +31,14 @@ module RuboCop
       # @example EnforcedStyle: aggressive
       #   # bad
       #   # this will return a Relation that pluck is called on
-      #   Model.where(cond: true).pluck(:id).distinct
+      #   Model.where(cond: true).pluck(:id).uniq
       #
       #   # bad
       #   # an association on an instance will return a CollectionProxy
-      #   instance.assoc.pluck(:id).distinct
+      #   instance.assoc.pluck(:id).uniq
       #
       #   # bad
-      #   Model.pluck(:id).distinct
+      #   Model.pluck(:id).uniq
       #
       #   # good
       #   Model.distinct.pluck(:id)

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