rubocop-rails 2.5.0 → 2.7.1

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/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

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

@@ -55,11 +55,8 @@ module RuboCop
       #     end
       #   end
       class RedundantReceiverInWithOptions < Cop
-        extend TargetRailsVersion
         include RangeHelp
 
-        minimum_target_rails_version 4.2
-
         MSG = 'Redundant receiver in `with_options`.'
 
         def_node_matcher :with_options?, <<~PATTERN

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

@@ -0,0 +1,40 @@
+# 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_inline_option?, <<~PATTERN
+          (send nil? :render (hash <(pair {(sym :inline) (str "inline")} _) ...>))
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if render_with_inline_option?(node)
+        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/save_bang.rb

@@ -9,14 +9,14 @@ module RuboCop
       #
       # This will allow:
       #
-      # - update or save calls, assigned to a variable,
+      # * update or save calls, assigned to a variable,
       #   or used as a condition in an if/unless/case statement.
-      # - create calls, assigned to a variable that then has a
+      # * create calls, assigned to a variable that then has a
       #   call to `persisted?`, or whose return value is checked by
       #   `persisted?` immediately
-      # - calls if the result is explicitly returned from methods and blocks,
+      # * calls if the result is explicitly returned from methods and blocks,
       #   or provided as arguments.
-      # - calls whose signature doesn't look like an ActiveRecord
+      # * calls whose signature doesn't look like an ActiveRecord
       #   persistence method.
       #
       # By default it will also allow implicit returns from methods and blocks.
@@ -218,9 +218,7 @@ module RuboCop
         def check_used_in_condition_or_compound_boolean(node)
           return false unless in_condition_or_compound_boolean?(node)
 
-          unless MODIFY_PERSIST_METHODS.include?(node.method_name)
-            add_offense_for_node(node, CREATE_CONDITIONAL_MSG)
-          end
+          add_offense_for_node(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
 
           true
         end
@@ -248,6 +246,7 @@ module RuboCop
 
         def allowed_receiver?(node)
           return false unless node.receiver
+          return true if node.receiver.const_name == 'ENV'
           return false unless cop_config['AllowedReceivers']
 
           cop_config['AllowedReceivers'].any? do |allowed_receiver|

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,27 +42,50 @@ 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
-          (send (const nil? :FileUtils) :touch ...)
+          {
+            (send (const nil? :FileUtils) :touch ...)
+            (send _ :touch {true false})
+          }
+        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)
@@ -74,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