rubocop-rails 2.6.0 → 2.9.0

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

@@ -36,10 +36,12 @@ module RuboCop
       #   foo&.bar
       #   foo&.bar(baz)
       #   foo&.bar { |e| e.baz }
-      class SafeNavigation < Cop
+      class SafeNavigation < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use safe navigation (`&.`) instead of `%<try>s`.'
+        RESTRICT_ON_SEND = %i[try try!].freeze
 
         def_node_matcher :try_call, <<~PATTERN
           (send !nil? ${:try :try!} $_ ...)
@@ -48,26 +50,25 @@ 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))
+            add_offense(node, message: format(MSG, try: try_method)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           method_node, *params = *node.arguments
           method = method_node.source[1..-1]
 
-          range = range_between(node.loc.dot.begin_pos,
-                                node.loc.expression.end_pos)
+          range = range_between(node.loc.dot.begin_pos, node.loc.expression.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(range, replacement(method, params))
-          end
+          corrector.replace(range, replacement(method, params))
         end
 
-        private
-
         def replacement(method, params)
           new_params = params.map(&:source).join(', ')
 

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

@@ -19,7 +19,9 @@ module RuboCop
       #   do_something if foo.blank?
       #   do_something unless foo.blank?
       #
-      class SafeNavigationWithBlank < Cop
+      class SafeNavigationWithBlank < Base
+        extend AutoCorrector
+
         MSG =
           'Avoid calling `blank?` with the safe navigation operator ' \
           'in conditionals.'
@@ -31,15 +33,8 @@ module RuboCop
         def on_if(node)
           return unless safe_navigation_blank_in_conditional?(node)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              safe_navigation_blank_in_conditional?(node).location.dot,
-              '.'
-            )
+          add_offense(node) do |corrector|
+            corrector.replace(safe_navigation_blank_in_conditional?(node).location.dot, '.')
           end
         end
       end

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

@@ -98,8 +98,9 @@ module RuboCop
       #   Services::Service::Mailer.update(message: 'Message')
       #   Service::Mailer::update
       #
-      class SaveBang < Cop
+      class SaveBang < Base
         include NegativeConditional
+        extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return ' \
               'value is not checked.'
@@ -113,11 +114,10 @@ module RuboCop
                                     first_or_create find_or_create_by].freeze
         MODIFY_PERSIST_METHODS = %i[save
                                     update update_attributes destroy].freeze
-        PERSIST_METHODS = (CREATE_PERSIST_METHODS +
-                           MODIFY_PERSIST_METHODS).freeze
+        RESTRICT_ON_SEND = (CREATE_PERSIST_METHODS + MODIFY_PERSIST_METHODS).freeze
 
-        def join_force?(force_class)
-          force_class == VariableForce
+        def self.joining_forces
+          VariableForce
         end
 
         def after_leaving_scope(scope, _variable_table)
@@ -135,10 +135,10 @@ module RuboCop
           return unless persist_method?(node, CREATE_PERSIST_METHODS)
           return if persisted_referenced?(assignment)
 
-          add_offense_for_node(node, CREATE_MSG)
+          register_offense(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)
@@ -148,25 +148,22 @@ module RuboCop
           return if explicit_return?(node)
           return if checked_immediately?(node)
 
-          add_offense_for_node(node)
+          register_offense(node, MSG)
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
         alias on_csend on_send
 
-        def autocorrect(node)
-          save_loc = node.loc.selector
-          new_method = "#{node.method_name}!"
-
-          ->(corrector) { corrector.replace(save_loc, new_method) }
-        end
-
         private
 
-        def add_offense_for_node(node, msg = MSG)
-          name = node.method_name
-          full_message = format(msg, prefer: "#{name}!", current: name.to_s)
+        def register_offense(node, msg)
+          current_method = node.method_name
+          bang_method = "#{current_method}!"
+          full_message = format(msg, prefer: bang_method, current: current_method)
 
-          add_offense(node, location: :selector, message: full_message)
+          range = node.loc.selector
+          add_offense(range, message: full_message) do |corrector|
+            corrector.replace(range, bang_method)
+          end
         end
 
         def right_assignment_node(assignment)
@@ -218,7 +215,7 @@ module RuboCop
         def check_used_in_condition_or_compound_boolean(node)
           return false unless in_condition_or_compound_boolean?(node)
 
-          add_offense_for_node(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
+          register_offense(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
 
           true
         end
@@ -318,7 +315,7 @@ module RuboCop
           assignment&.lvasgn_type?
         end
 
-        def persist_method?(node, methods = PERSIST_METHODS)
+        def persist_method?(node, methods = RESTRICT_ON_SEND)
           methods.include?(node.method_name) &&
             expected_signature?(node) &&
             !allowed_receiver?(node)

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

@@ -13,8 +13,9 @@ module RuboCop
       #
       #   # good
       #   scope :something, -> { where(something: true) }
-      class ScopeArgs < Cop
+      class ScopeArgs < Base
         MSG = 'Use `lambda`/`proc` instead of a plain method call.'
+        RESTRICT_ON_SEND = %i[scope].freeze
 
         def_node_matcher :scope?, '(send nil? :scope _ $send)'
 

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

@@ -0,0 +1,74 @@
+# 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 < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+
+        PREFERRED_METHODS = {
+          translate: :t,
+          localize: :l
+        }.freeze
+
+        RESTRICT_ON_SEND = PREFERRED_METHODS.keys.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)
+            range = node.loc.selector
+
+            add_offense(range, message: message) do |corrector|
+              corrector.replace(range, PREFERRED_METHODS[method_name])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -7,7 +7,7 @@ module RuboCop
       # validations which are listed in
       # https://guides.rubyonrails.org/active_record_validations.html#skipping-validations
       #
-      # Methods may be ignored from this rule by configuring a `Whitelist`.
+      # Methods may be ignored from this rule by configuring a `AllowedMethods`.
       #
       # @example
       #   # bad
@@ -26,7 +26,7 @@ module RuboCop
       #   user.update(website: 'example.com')
       #   FileUtils.touch('file')
       #
-      # @example Whitelist: ["touch"]
+      # @example AllowedMethods: ["touch"]
       #   # bad
       #   DiscussionBoard.decrement_counter(:post_count, 5)
       #   DiscussionBoard.increment_counter(:post_count, 5)
@@ -35,19 +35,25 @@ module RuboCop
       #   # good
       #   user.touch
       #
-      class SkipsModelValidations < Cop
+      class SkipsModelValidations < Base
         MSG = 'Avoid using `%<method>s` because it skips validations.'
 
         METHODS_WITH_ARGUMENTS = %w[decrement!
                                     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)
+          add_offense(node.loc.selector, message: message(node))
         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/squished_sql_heredocs.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Checks SQL heredocs to use `.squish`.
+      # Some SQL syntax (e.g. PostgreSQL comments and functions) requires newlines
+      # to be preserved in order to work, thus auto-correction for this cop is not safe.
+      #
+      # @example
+      #   # bad
+      #   <<-SQL
+      #     SELECT * FROM posts;
+      #   SQL
+      #
+      #   <<-SQL
+      #     SELECT * FROM posts
+      #       WHERE id = 1
+      #   SQL
+      #
+      #   execute(<<~SQL, "Post Load")
+      #     SELECT * FROM posts
+      #       WHERE post_id = 1
+      #   SQL
+      #
+      #   # good
+      #   <<-SQL.squish
+      #     SELECT * FROM posts;
+      #   SQL
+      #
+      #   <<~SQL.squish
+      #     SELECT * FROM table
+      #       WHERE id = 1
+      #   SQL
+      #
+      #   execute(<<~SQL.squish, "Post Load")
+      #     SELECT * FROM posts
+      #       WHERE post_id = 1
+      #   SQL
+      #
+      class SquishedSQLHeredocs < Base
+        include Heredoc
+        extend AutoCorrector
+
+        SQL = 'SQL'
+        SQUISH = '.squish'
+        MSG = 'Use `%<expect>s` instead of `%<current>s`.'
+
+        def on_heredoc(node)
+          return unless offense_detected?(node)
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(node, SQUISH)
+          end
+        end
+
+        private
+
+        def offense_detected?(node)
+          sql_heredoc?(node) && !using_squish?(node)
+        end
+
+        def sql_heredoc?(node)
+          delimiter_string(node) == SQL
+        end
+
+        def using_squish?(node)
+          node.parent&.send_type? && node.parent&.method?(:squish)
+        end
+
+        def message(node)
+          format(
+            MSG,
+            expect: "#{node.source}#{SQUISH}",
+            current: node.source
+          )
+        end
+      end
+    end
+  end
+end