rubocop-rails 2.7.1 → 2.10.0

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

@@ -13,11 +13,12 @@ module RuboCop
       #
       #   # good
       #   User.find_by(name: 'Bruce')
-      class FindBy < Cop
+      class FindBy < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `find_by` instead of `where.%<method>s`.'
-        TARGET_SELECTORS = %i[first take].freeze
+        RESTRICT_ON_SEND = %i[first take].freeze
 
         def_node_matcher :where_first?, <<~PATTERN
           (send ({send csend} _ :where ...) {:first :take})
@@ -26,28 +27,27 @@ module RuboCop
         def on_send(node)
           return unless where_first?(node)
 
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.loc.selector.end_pos)
+          range = range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
 
-          add_offense(node, location: range,
-                            message: format(MSG, method: node.method_name))
+          add_offense(range, message: format(MSG, method: node.method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           # Don't autocorrect where(...).first, because it can return different
           # results from find_by. (They order records differently, so the
           # 'first' record can be different.)
           return if node.method?(:first)
 
           where_loc = node.receiver.loc.selector
-          first_loc = range_between(node.loc.dot.begin_pos,
-                                    node.loc.selector.end_pos)
+          first_loc = range_between(node.loc.dot.begin_pos, node.loc.selector.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(where_loc, 'find_by')
-            corrector.replace(first_loc, '')
-          end
+          corrector.replace(where_loc, 'find_by')
+          corrector.replace(first_loc, '')
         end
       end
     end

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

@@ -16,10 +16,12 @@ module RuboCop
       #   # good
       #   User.find(id)
       #
-      class FindById < Cop
+      class FindById < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[take! find_by_id! find_by!].freeze
 
         def_node_matcher :where_take?, <<~PATTERN
           (send
@@ -38,41 +40,30 @@ module RuboCop
         def on_send(node)
           where_take?(node) do |where, id_value|
             range = where_take_offense_range(node, where)
-
-            good_method = build_good_method(id_value)
             bad_method = build_where_take_bad_method(id_value)
-            message = format(MSG, good_method: good_method, bad_method: bad_method)
 
-            add_offense(node, location: range, message: message)
+            register_offense(range, id_value, bad_method)
           end
 
           find_by?(node) do |id_value|
             range = find_by_offense_range(node)
-
-            good_method = build_good_method(id_value)
             bad_method = build_find_by_bad_method(node, id_value)
-            message = format(MSG, good_method: good_method, bad_method: bad_method)
 
-            add_offense(node, location: range, message: message)
+            register_offense(range, id_value, bad_method)
           end
         end
 
-        def autocorrect(node)
-          if (matches = where_take?(node))
-            where, id_value = *matches
-            range = where_take_offense_range(node, where)
-          elsif (id_value = find_by?(node))
-            range = find_by_offense_range(node)
-          end
+        private
+
+        def register_offense(range, id_value, bad_method)
+          good_method = build_good_method(id_value)
+          message = format(MSG, good_method: good_method, bad_method: bad_method)
 
-          lambda do |corrector|
-            replacement = build_good_method(id_value)
-            corrector.replace(range, replacement)
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, good_method)
           end
         end
 
-        private
-
         def where_take_offense_range(node, where)
           range_between(where.loc.selector.begin_pos, node.loc.expression.end_pos)
         end

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

@@ -12,38 +12,39 @@ module RuboCop
       #
       #   # good
       #   User.all.find_each
-      class FindEach < Cop
+      #
+      # @example IgnoredMethods: ['order']
+      #   # good
+      #   User.order(:foo).each
+      class FindEach < Base
+        include ActiveRecordHelper
+        extend AutoCorrector
+
         MSG = 'Use `find_each` instead of `each`.'
+        RESTRICT_ON_SEND = %i[each].freeze
 
         SCOPE_METHODS = %i[
           all eager_load includes joins left_joins left_outer_joins not preload
           references unscoped where
         ].freeze
-        IGNORED_METHODS = %i[order limit select].freeze
 
         def on_send(node)
-          return unless node.receiver&.send_type? &&
-                        node.method?(:each)
-
+          return unless node.receiver&.send_type?
           return unless SCOPE_METHODS.include?(node.receiver.method_name)
-          return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
+          return if node.receiver.receiver.nil? && !inherit_active_record_base?(node)
+          return if ignored?(node)
 
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'find_each') }
+          range = node.loc.selector
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'find_each')
+          end
         end
 
         private
 
-        def method_chain(node)
-          node.each_node(:send).map(&:method_name)
-        end
-
-        def ignored_by_find_each?(relation_method)
-          # Active Record's #find_each ignores various extra parameters
-          IGNORED_METHODS.include?(relation_method)
+        def ignored?(node)
+          method_chain = node.each_node(:send).map(&:method_name)
+          (cop_config['IgnoredMethods'].map(&:to_sym) & method_chain).any?
         end
       end
     end

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

@@ -11,13 +11,14 @@ module RuboCop
       #
       #   # good
       #   # has_many :ingredients, through: :recipe_ingredients
-      class HasAndBelongsToMany < Cop
+      class HasAndBelongsToMany < Base
         MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
+        RESTRICT_ON_SEND = %i[has_and_belongs_to_many].freeze
 
         def on_send(node)
           return unless node.command?(:has_and_belongs_to_many)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
       end
     end

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

@@ -5,7 +5,9 @@ module RuboCop
     module Rails
       # This cop looks for `has_many` or `has_one` associations that don't
       # specify a `:dependent` option.
-      # It doesn't register an offense if `:through` option was specified.
+      #
+      # It doesn't register an offense if `:through` or `dependent: nil`
+      # is specified, or if the model is read-only.
       #
       # @example
       #   # bad
@@ -18,10 +20,21 @@ module RuboCop
       #   class User < ActiveRecord::Base
       #     has_many :comments, dependent: :restrict_with_exception
       #     has_one :avatar, dependent: :destroy
+      #     has_many :articles, dependent: nil
       #     has_many :patients, through: :appointments
       #   end
-      class HasManyOrHasOneDependent < Cop
+      #
+      #   class User < ActiveRecord::Base
+      #     has_many :comments
+      #     has_one :avatar
+      #
+      #     def readonly?
+      #       true
+      #     end
+      #   end
+      class HasManyOrHasOneDependent < Base
         MSG = 'Specify a `:dependent` option.'
+        RESTRICT_ON_SEND = %i[has_many has_one].freeze
 
         def_node_search :active_resource_class?, <<~PATTERN
           (const (const nil? :ActiveResource) :Base)
@@ -36,7 +49,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :dependent_option?, <<~PATTERN
-          (pair (sym :dependent) !nil)
+          (pair (sym :dependent) {!nil (nil)})
         PATTERN
 
         def_node_matcher :present_option?, <<~PATTERN
@@ -50,24 +63,38 @@ module RuboCop
             (args) ...)
         PATTERN
 
-        def on_send(node)
-          return if active_resource?(node.parent)
+        def_node_matcher :association_extension_block?, <<~PATTERN
+          (block
+            (send nil? :has_many _)
+            (args) ...)
+        PATTERN
 
-          unless association_without_options?(node)
-            return if valid_options?(association_with_options?(node))
-          end
+        def_node_matcher :readonly?, <<~PATTERN
+          (def :readonly?
+            (args)
+            (true))
+        PATTERN
 
+        def on_send(node)
+          return if active_resource?(node.parent) || readonly_model?(node)
+          return if !association_without_options?(node) && valid_options?(association_with_options?(node))
           return if valid_options_in_with_options_block?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
 
         private
 
+        def readonly_model?(node)
+          return false unless (parent = node.parent)
+
+          parent.each_descendant(:def).any? { |def_node| readonly?(def_node) }
+        end
+
         def valid_options_in_with_options_block?(node)
           return true unless node.parent
 
-          n = node.parent.begin_type? ? node.parent.parent : node.parent
+          n = node.parent.begin_type? || association_extension_block?(node.parent) ? node.parent.parent : node.parent
 
           contain_valid_options_in_with_options_block?(n)
         end

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

@@ -13,6 +13,9 @@ module RuboCop
       # variable, consider moving the behaviour elsewhere, for
       # example to a model, decorator or presenter.
       #
+      # Provided that a class inherits `ActionView::Helpers::FormBuilder`,
+      # an offense will not be registered.
+      #
       # @example
       #   # bad
       #   def welcome_message
@@ -23,15 +26,40 @@ module RuboCop
       #   def welcome_message(user)
       #     "Hello #{user.name}"
       #   end
-      class HelperInstanceVariable < Cop
+      #
+      #   # good
+      #   class MyFormBuilder < ActionView::Helpers::FormBuilder
+      #     @template.do_something
+      #   end
+      class HelperInstanceVariable < Base
         MSG = 'Do not use instance variables in helpers.'
 
+        def_node_matcher :form_builder_class?, <<~PATTERN
+          (const
+            (const
+               (const nil? :ActionView) :Helpers) :FormBuilder)
+        PATTERN
+
         def on_ivar(node)
+          return if inherit_form_builder?(node)
+
           add_offense(node)
         end
 
         def on_ivasgn(node)
-          add_offense(node, location: :name)
+          return if node.parent.or_asgn_type? || inherit_form_builder?(node)
+
+          add_offense(node.loc.name)
+        end
+
+        private
+
+        def inherit_form_builder?(node)
+          node.each_ancestor(:class) do |class_node|
+            return true if form_builder_class?(class_node.parent_class)
+          end
+
+          false
         end
       end
     end

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

@@ -16,7 +16,10 @@ module RuboCop
       #
       #   # good
       #   get :new, params: { user_id: 1 }
-      class HttpPositionalArguments < Cop
+      #   get :new, **options
+      class HttpPositionalArguments < Base
+        include RangeHelp
+        extend AutoCorrector
         extend TargetRailsVersion
 
         MSG = 'Use keyword arguments instead of ' \
@@ -24,36 +27,37 @@ module RuboCop
         KEYWORD_ARGS = %i[
           method params session body flash xhr as headers env to
         ].freeze
-        HTTP_METHODS = %i[get post put patch delete head].freeze
+        RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
 
         minimum_target_rails_version 5.0
 
         def_node_matcher :http_request?, <<~PATTERN
-          (send nil? {#{HTTP_METHODS.map(&:inspect).join(' ')}} !nil? $_ ...)
+          (send nil? {#{RESTRICT_ON_SEND.map(&:inspect).join(' ')}} !nil? $_ ...)
+        PATTERN
+
+        def_node_matcher :kwsplat_hash?, <<~PATTERN
+          (hash (kwsplat _))
         PATTERN
 
         def on_send(node)
           http_request?(node) do |data|
             return unless needs_conversion?(data)
 
-            add_offense(node, location: :selector,
-                              message: format(MSG, verb: node.method_name))
-          end
-        end
-
-        # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
-        #
-        # @return lambda of auto correct procedure
-        # the result should look like:
-        #     get :new, params: { user_id: @user.id }, session: {}
-        # the http_method is the method used to call the controller
-        # the controller node can be a symbol, method, object or string
-        # that represents the path/action on the Rails controller
-        # the data is the http parameters and environment sent in
-        # the Rails 5 http call
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, correction(node))
+            message = format(MSG, verb: node.method_name)
+
+            add_offense(highlight_range(node), message: message) do |corrector|
+              # given a pre Rails 5 method: get :new, {user_id: @user.id}, {}
+              #
+              # @return lambda of auto correct procedure
+              # the result should look like:
+              #     get :new, params: { user_id: @user.id }, session: {}
+              # the http_method is the method used to call the controller
+              # the controller node can be a symbol, method, object or string
+              # that represents the path/action on the Rails controller
+              # the data is the http parameters and environment sent in
+              # the Rails 5 http call
+              corrector.replace(node.loc.expression, correction(node))
+            end
           end
         end
 
@@ -61,6 +65,7 @@ module RuboCop
 
         def needs_conversion?(data)
           return true unless data.hash_type?
+          return false if kwsplat_hash?(data)
 
           data.each_pair.none? do |pair|
             special_keyword_arg?(pair.key) ||
@@ -76,6 +81,12 @@ module RuboCop
           node.sym_type? && node.value == :format
         end
 
+        def highlight_range(node)
+          _http_path, *data = *node.arguments
+
+          range_between(data.first.source_range.begin_pos, data.last.source_range.end_pos)
+        end
+
         def convert_hash_data(data, type)
           return '' if data.hash_type? && data.empty?
 

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

@@ -31,8 +31,11 @@ module RuboCop
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
       #
-      class HttpStatus < Cop
+      class HttpStatus < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = %i[render redirect_to].freeze
 
         def_node_matcher :http_status, <<~PATTERN
           {
@@ -53,14 +56,9 @@ module RuboCop
             checker = checker_class.new(status)
             return unless checker.offensive?
 
-            add_offense(checker.node, message: checker.message)
-          end
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            checker = checker_class.new(node)
-            corrector.replace(node.loc.expression, checker.preferred_style)
+            add_offense(checker.node, message: checker.message) do |corrector|
+              corrector.replace(checker.node.loc.expression, checker.preferred_style)
+            end
           end
         end