rubocop-rails 2.8.1 → 2.11.0

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

@@ -25,7 +25,9 @@ module RuboCop
       #     do_something
       #   end
       #
-      class RakeEnvironment < Cop
+      class RakeEnvironment < Base
+        extend AutoCorrector
+
         MSG = 'Include `:environment` task as a dependency for all Rake tasks.'
 
         def_node_matcher :task_definition?, <<~PATTERN
@@ -37,16 +39,12 @@ module RuboCop
             return if task_name(task_method) == :default
             return if with_dependencies?(task_method)
 
-            add_offense(task_method)
-          end
-        end
+            add_offense(task_method) do |corrector|
+              task_name = task_method.arguments[0]
+              task_dependency = correct_task_dependency(task_name)
 
-        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)
+              corrector.replace(task_name.loc.expression, task_dependency)
+            end
           end
         end
 

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,8 +15,10 @@ 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} _ _ ?
@@ -23,12 +27,22 @@ module RuboCop
         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,19 @@ 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].to_set.freeze
 
         def on_casgn(node)
-          relative_date_assignment?(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name: method_name))
+          nested_relative_date(node) do |method_name|
+            add_offense(node, message: message(method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -47,21 +51,23 @@ module RuboCop
           lhs.children.zip(rhs.children).each do |(name, value)|
             next unless name.casgn_type?
 
-            relative_date?(value) do |method_name|
-              add_offense(node,
-                          location: offense_range(name, value),
-                          message: format(MSG, method_name: method_name))
+            nested_relative_date(value) do |method_name|
+              add_offense(offense_range(name, value), message: message(method_name)) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
           end
         end
 
         def on_or_asgn(node)
-          relative_date_or_assignment?(node) do |method_name|
+          relative_date_or_assignment(node) do |method_name|
             add_offense(node, message: format(MSG, method_name: method_name))
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return unless node.casgn_type?
 
           scope, const_name, value = *node
@@ -71,33 +77,34 @@ 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 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}))
-            (casgn _ _ ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before})))
-            (casgn _ _ ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _))
-          }
-        PATTERN
+        def nested_relative_date(node, &callback)
+          return if node.block_type?
+
+          node.each_child_node do |child|
+            nested_relative_date(child, &callback)
+          end
+
+          relative_date(node, &callback)
+        end
 
-        def_node_matcher :relative_date_or_assignment?, <<~PATTERN
-          (:or_asgn (casgn _ _) (send _ ${:since :from_now :after :ago :until :before}))
+        def_node_matcher :relative_date_or_assignment, <<~PATTERN
+          (:or_asgn (casgn _ _) (send _ $RELATIVE_DATE_METHODS))
         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})
-          }
+        def_node_matcher :relative_date, <<~PATTERN
+          (send _ $RELATIVE_DATE_METHODS)
         PATTERN
       end
     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")} _) ...>))