rubocop-rails 2.7.1 → 2.10.0

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

@@ -23,8 +23,11 @@ module RuboCop
       #   # good
       #   x = self[:attr]
       #   self[:attr] = val
-      class ReadWriteAttribute < Cop
+      class ReadWriteAttribute < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `%<prefer>s` over `%<current>s`.'
+        RESTRICT_ON_SEND = %i[read_attribute write_attribute].freeze
 
         def_node_matcher :read_write_attribute?, <<~PATTERN
           {
@@ -36,18 +39,16 @@ module RuboCop
         def on_send(node)
           return unless read_write_attribute?(node)
 
-          add_offense(node, location: :selector)
-        end
+          add_offense(node.loc.selector, message: message(node)) do |corrector|
+            case node.method_name
+            when :read_attribute
+              replacement = read_attribute_replacement(node)
+            when :write_attribute
+              replacement = write_attribute_replacement(node)
+            end
 
-        def autocorrect(node)
-          case node.method_name
-          when :read_attribute
-            replacement = read_attribute_replacement(node)
-          when :write_attribute
-            replacement = write_attribute_replacement(node)
+            corrector.replace(node.source_range, replacement)
           end
-
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
         end
 
         private

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

@@ -26,8 +26,9 @@ module RuboCop
       #   # Here, `nil` is valid but `''` is not
       #   validates :x, length: { is: 5 }, allow_nil: true, allow_blank: false
       #
-      class RedundantAllowNil < Cop
+      class RedundantAllowNil < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG_SAME =
           '`allow_nil` is redundant when `allow_blank` has the same value.'
@@ -35,59 +36,56 @@ module RuboCop
         MSG_ALLOW_NIL_FALSE =
           '`allow_nil: false` is redundant when `allow_blank` is true.'
 
-        def on_send(node)
-          return unless node.method?(:validates)
+        RESTRICT_ON_SEND = %i[validates].freeze
 
+        def on_send(node)
           allow_nil, allow_blank = find_allow_nil_and_allow_blank(node)
           return unless allow_nil && allow_blank
 
           allow_nil_val = allow_nil.children.last
           allow_blank_val = allow_blank.children.last
 
-          offense(allow_nil_val, allow_blank_val, allow_nil)
+          if allow_nil_val.type == allow_blank_val.type
+            register_offense(allow_nil, MSG_SAME)
+          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
+            register_offense(allow_nil, MSG_ALLOW_NIL_FALSE)
+          end
         end
 
-        def autocorrect(node)
-          prv_sib = previous_sibling(node)
-          nxt_sib = next_sibling(node)
+        private
+
+        def register_offense(allow_nil, message)
+          add_offense(allow_nil, message: message) do |corrector|
+            prv_sib = previous_sibling(allow_nil)
+            nxt_sib = next_sibling(allow_nil)
 
-          lambda do |corrector|
             if nxt_sib
-              corrector.remove(range_between(node_beg(node), node_beg(nxt_sib)))
+              corrector.remove(range_between(node_beg(allow_nil), node_beg(nxt_sib)))
             elsif prv_sib
-              corrector.remove(range_between(node_end(prv_sib), node_end(node)))
+              corrector.remove(range_between(node_end(prv_sib), node_end(allow_nil)))
             else
-              corrector.remove(node.loc.expression)
+              corrector.remove(allow_nil.loc.expression)
             end
           end
         end
 
-        private
-
-        def offense(allow_nil_val, allow_blank_val, allow_nil)
-          if allow_nil_val.type == allow_blank_val.type
-            add_offense(allow_nil, message: MSG_SAME)
-          elsif allow_nil_val.false_type? && allow_blank_val.true_type?
-            add_offense(allow_nil, message: MSG_ALLOW_NIL_FALSE)
-          end
-        end
-
         def find_allow_nil_and_allow_blank(node)
-          allow_nil = nil
-          allow_blank = nil
+          allow_nil, allow_blank = nil
 
-          node.each_descendant do |descendant|
-            next unless descendant.pair_type?
+          node.each_child_node do |child_node|
+            if child_node.pair_type?
+              key = child_node.children.first.source
 
-            key = descendant.children.first.source
-
-            allow_nil = descendant if key == 'allow_nil'
-            allow_blank = descendant if key == 'allow_blank'
+              allow_nil = child_node if key == 'allow_nil'
+              allow_blank = child_node if key == 'allow_blank'
+            end
+            return [allow_nil, allow_blank] if allow_nil && allow_blank
 
-            break if allow_nil && allow_blank
+            found_in_children_nodes = find_allow_nil_and_allow_blank(child_node)
+            return found_in_children_nodes if found_in_children_nodes
           end
 
-          [allow_nil, allow_blank]
+          nil
         end
 
         def previous_sibling(node)

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

@@ -24,10 +24,12 @@ module RuboCop
       #   class Comment
       #     belongs_to :author, foreign_key: 'user_id'
       #   end
-      class RedundantForeignKey < Cop
+      class RedundantForeignKey < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Specifying the default value for `foreign_key` is redundant.'
+        RESTRICT_ON_SEND = %i[belongs_to has_one has_many has_and_belongs_to_many].freeze
 
         def_node_matcher :association_with_foreign_key, <<~PATTERN
           (send nil? ${:belongs_to :has_one :has_many :has_and_belongs_to_many} ({sym str} $_)
@@ -38,18 +40,13 @@ module RuboCop
         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
+              add_offense(foreign_key_pair.loc.expression) do |corrector|
+                range = range_with_surrounding_space(range: foreign_key_pair.source_range, side: :left)
+                range = range_with_surrounding_comma(range, :left)
 
-        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)
+                corrector.remove(range)
+              end
+            end
           end
         end
 

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

@@ -54,8 +54,9 @@ module RuboCop
       #       merger.invoke(another_receiver)
       #     end
       #   end
-      class RedundantReceiverInWithOptions < Cop
+      class RedundantReceiverInWithOptions < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Redundant receiver in `with_options`.'
 
@@ -86,22 +87,22 @@ module RuboCop
             if send_nodes.all? { |n| same_value?(arg, n.receiver) }
               send_nodes.each do |send_node|
                 receiver = send_node.receiver
-                add_offense(send_node, location: receiver.source_range)
+                add_offense(receiver.source_range) do |corrector|
+                  autocorrect(corrector, send_node)
+                end
               end
             end
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.receiver.source_range)
-            corrector.remove(node.loc.dot)
-            corrector.remove(block_argument_range(node))
-          end
-        end
-
         private
 
+        def autocorrect(corrector, node)
+          corrector.remove(node.receiver.source_range)
+          corrector.remove(node.loc.dot)
+          corrector.remove(block_argument_range(node))
+        end
+
         def block_argument_range(node)
           block_node = node.each_ancestor(:block).first
           block_argument = block_node.children[1].source_range

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

@@ -5,6 +5,8 @@ module RuboCop
     module Rails
       # This cop checks if the value of the option `class_name`, in
       # the definition of a reflection is a string.
+      # It is marked as unsafe because it cannot be determined whether
+      # constant or method return value specified to `class_name` is a string.
       #
       # @example
       #   # bad
@@ -13,22 +15,34 @@ module RuboCop
       #
       #   # good
       #   has_many :accounts, class_name: 'Account'
-      class ReflectionClassName < Cop
+      class ReflectionClassName < Base
         MSG = 'Use a string value for `class_name`.'
+        RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
+        ALLOWED_REFLECTION_CLASS_TYPES = %i[dstr str sym].freeze
 
         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
 
         def_node_matcher :reflection_class_name, <<~PATTERN
-          (pair (sym :class_name) [!dstr !str !sym])
+          (pair (sym :class_name) #reflection_class_value?)
         PATTERN
 
         def on_send(node)
           association_with_reflection(node) do |reflection_class_name|
-            add_offense(node, location: reflection_class_name.loc.expression)
+            add_offense(reflection_class_name.loc.expression)
+          end
+        end
+
+        private
+
+        def reflection_class_value?(class_value)
+          if class_value.send_type?
+            !class_value.method?(:to_s) || class_value.receiver.const_type?
+          else
+            !ALLOWED_REFLECTION_CLASS_TYPES.include?(class_value.type)
           end
         end
       end

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

@@ -28,8 +28,9 @@ module RuboCop
       #   refute_empty [1, 2, 3]
       #   refute_equal true, false
       #
-      class RefuteMethods < Cop
+      class RefuteMethods < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
 
@@ -53,21 +54,19 @@ module RuboCop
         REFUTE_METHODS = CORRECTIONS.keys.freeze
         ASSERT_NOT_METHODS = CORRECTIONS.values.freeze
 
+        RESTRICT_ON_SEND = REFUTE_METHODS + ASSERT_NOT_METHODS
+
         def_node_matcher :offensive?, '(send nil? #bad_method? ...)'
 
         def on_send(node)
           return unless offensive?(node)
 
-          message = offense_message(node.method_name)
-          add_offense(node, location: :selector, message: message)
-        end
-
-        def autocorrect(node)
-          bad_method = node.method_name
-          good_method = convert_good_method(bad_method)
+          method_name = node.method_name
+          message = offense_message(method_name)
+          range = node.loc.selector
 
-          lambda do |corrector|
-            corrector.replace(node.loc.selector, good_method.to_s)
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, convert_good_method(method_name))
           end
         end
 

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

@@ -27,15 +27,23 @@ module RuboCop
       #       1.week.since
       #     end
       #   end
-      class RelativeDateConstant < Cop
+      class RelativeDateConstant < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Do not assign %<method_name>s to constants as it ' \
+        MSG = 'Do not assign `%<method_name>s` to constants as it ' \
               'will be evaluated only once.'
+        RELATIVE_DATE_METHODS = %i[since from_now after ago until before yesterday tomorrow].freeze
 
         def on_casgn(node)
-          relative_date_assignment?(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name: method_name))
+          return if node.children[2]&.block_type?
+
+          node.each_descendant(:send) do |send_node|
+            relative_date?(send_node) do |method_name|
+              add_offense(node, message: message(method_name)) do |corrector|
+                autocorrect(corrector, node)
+              end
+            end
           end
         end
 
@@ -48,10 +56,9 @@ module RuboCop
             next unless name.casgn_type?
 
             relative_date?(value) do |method_name|
-              add_offense(node,
-                          location: range_between(name.loc.expression.begin_pos,
-                                                  value.loc.expression.end_pos),
-                          message: format(MSG, method_name: method_name))
+              add_offense(offense_range(name, value), message: message(method_name)) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
           end
         end
@@ -62,7 +69,9 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return unless node.casgn_type?
 
           scope, const_name, value = *node
@@ -72,28 +81,31 @@ module RuboCop
           new_code = ["def self.#{const_name.downcase}",
                       "#{indent}#{value.source}",
                       'end'].join("\n#{indent}")
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+
+          corrector.replace(node.source_range, new_code)
         end
 
-        private
+        def message(method_name)
+          format(MSG, method_name: method_name)
+        end
 
-        def_node_matcher :relative_date_assignment?, <<~PATTERN
-          {
-            (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))
-            (casgn _ _ ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before})))
-            (casgn _ _ ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _))
-          }
-        PATTERN
+        def offense_range(name, value)
+          range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
+        end
+
+        def relative_date_method?(method_name)
+          RELATIVE_DATE_METHODS.include?(method_name)
+        end
 
         def_node_matcher :relative_date_or_assignment?, <<~PATTERN
-          (:or_asgn (casgn _ _) (send _ ${:since :from_now :after :ago :until :before}))
+          (:or_asgn (casgn _ _) (send _ $#relative_date_method?))
         PATTERN
 
         def_node_matcher :relative_date?, <<~PATTERN
           {
-            ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before}))
-            ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _)
-            (send _ ${:since :from_now :after :ago :until :before})
+            ({erange irange} _ (send _ $#relative_date_method?))
+            ({erange irange} (send _ $#relative_date_method?) _)
+            (send _ $#relative_date_method?)
           }
         PATTERN
       end

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

@@ -24,8 +24,9 @@ module RuboCop
       #     end
       #   end
       #
-      class RenderInline < Cop
+      class RenderInline < Base
         MSG = 'Prefer using a template over inline rendering.'
+        RESTRICT_ON_SEND = %i[render].freeze
 
         def_node_matcher :render_with_inline_option?, <<~PATTERN
           (send nil? :render (hash <(pair {(sym :inline) (str "inline")} _) ...>))

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

@@ -24,30 +24,25 @@ module RuboCop
       #   # bad - sets MIME type to `text/html`
       #   render text: 'Ruby!'
       #
-      class RenderPlainText < Cop
+      class RenderPlainText < Base
+        extend AutoCorrector
+
         MSG = 'Prefer `render plain:` over `render text:`.'
+        RESTRICT_ON_SEND = %i[render].freeze
 
         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
+            return unless compatible_content_type?(content_type_node)
+
+            add_offense(node) do |corrector|
+              rest_options = options_node.pairs - [option_node, content_type_node].compact
 
-            lambda do |corrector|
-              corrector.replace(
-                node,
-                replacement(rest_options, option_value)
-              )
+              corrector.replace(node, replacement(rest_options, option_value))
             end
           end
         end