rubocop-rails 2.5.1 → 2.8.0

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/reflection_class_name.rb

@@ -17,7 +17,7 @@ module RuboCop
         MSG = 'Use a string value for `class_name`.'
 
         def_node_matcher :association_with_reflection, <<~PATTERN
-          (send nil? {:has_many :has_one :belongs_to} _
+          (send nil? {:has_many :has_one :belongs_to} _ _ ?
             (hash <$#reflection_class_name ...>)
           )
         PATTERN

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

@@ -49,8 +49,7 @@ module RuboCop
 
             relative_date?(value) do |method_name|
               add_offense(node,
-                          location: range_between(name.loc.expression.begin_pos,
-                                                  value.loc.expression.end_pos),
+                          location: offense_range(name, value),
                           message: format(MSG, method_name: method_name))
             end
           end
@@ -77,6 +76,10 @@ module RuboCop
 
         private
 
+        def offense_range(name, value)
+          range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
+        end
+
         def_node_matcher :relative_date_assignment?, <<~PATTERN
           {
             (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))

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/reversible_migration.rb

@@ -129,6 +129,51 @@ module RuboCop
       #     end
       #   end
       #
+      # @example
+      #   # remove_columns
+      #
+      #   # bad
+      #   def change
+      #     remove_columns :users, :name, :email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     reversible do |dir|
+      #       dir.up do
+      #         remove_columns :users, :name, :email
+      #       end
+      #
+      #       dir.down do
+      #         add_column :users, :name, :string
+      #         add_column :users, :email, :string
+      #       end
+      #     end
+      #   end
+      #
+      #   # good (Rails >= 6.1, see https://github.com/rails/rails/pull/36589)
+      #   def change
+      #     remove_columns :users, :name, :email, type: :string
+      #   end
+      #
+      # @example
+      #   # remove_index
+      #
+      #   # bad
+      #   def change
+      #     remove_index :users, name: :index_users_on_email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, :email
+      #   end
+      #
+      #   # good
+      #   def change
+      #     remove_index :users, column: :email
+      #   end
+      #
       # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
       class ReversibleMigration < Cop
         MSG = '%<action>s is not reversible.'
@@ -153,6 +198,14 @@ module RuboCop
           (send nil? :change_table $_ ...)
         PATTERN
 
+        def_node_matcher :remove_columns_call, <<~PATTERN
+          (send nil? :remove_columns ... $_)
+        PATTERN
+
+        def_node_matcher :remove_index_call, <<~PATTERN
+          (send nil? :remove_index _ $_)
+        PATTERN
+
         def on_send(node)
           return unless within_change_method?(node)
           return if within_reversible_or_up_only_block?(node)
@@ -162,6 +215,8 @@ module RuboCop
           check_reversible_hash_node(node)
           check_remove_column_node(node)
           check_remove_foreign_key_node(node)
+          check_remove_columns_node(node)
+          check_remove_index_node(node)
         end
 
         def on_block(node)
@@ -237,6 +292,30 @@ module RuboCop
           end
         end
 
+        def check_remove_columns_node(node)
+          remove_columns_call(node) do |args|
+            unless all_hash_key?(args, :type) && target_rails_version >= 6.1
+              action = target_rails_version >= 6.1 ? 'remove_columns(without type)' : 'remove_columns'
+
+              add_offense(
+                node,
+                message: format(MSG, action: action)
+              )
+            end
+          end
+        end
+
+        def check_remove_index_node(node)
+          remove_index_call(node) do |args|
+            if args.hash_type? && !all_hash_key?(args, :column)
+              add_offense(
+                node,
+                message: format(MSG, action: 'remove_index(without column)')
+              )
+            end
+          end
+        end
+
         def check_change_table_offense(receiver, node)
           method_name = node.method_name
           return if receiver != node.receiver &&

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.
@@ -138,7 +138,7 @@ module RuboCop
           add_offense_for_node(node, CREATE_MSG)
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return unless persist_method?(node)
           return if return_value_assigned?(node)
@@ -150,7 +150,7 @@ module RuboCop
 
           add_offense_for_node(node)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_csend on_send
 
         def autocorrect(node)
@@ -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