rubocop-rails 2.0.1 → 2.19.1

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

@@ -26,84 +26,72 @@ 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.'
+        MSG_SAME = '`allow_nil` is redundant when `allow_blank` has the same value.'
 
-        MSG_ALLOW_NIL_FALSE =
-          '`allow_nil: false` is redundant when `allow_blank` is true.'
+        MSG_ALLOW_NIL_FALSE = '`allow_nil: false` is redundant when `allow_blank` is true.'
 
-        def on_send(node)
-          return unless node.method_name == :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 = allow_nil.left_sibling
+            nxt_sib = allow_nil.right_sibling
 
-          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)
             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
-
-          node.each_descendant do |descendant|
-            next unless descendant.pair_type?
+          allow_nil, allow_blank = nil
 
-            key = descendant.children.first.source
+          node.each_child_node do |child_node|
+            if child_node.pair_type?
+              key = child_node.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]
-        end
-
-        def previous_sibling(node)
-          node.parent.children[node.sibling_index - 1]
-        end
-
-        def next_sibling(node)
-          node.parent.children[node.sibling_index + 1]
+          nil
         end
 
         def node_beg(node)
-          node.loc.expression.begin_pos
+          node.source_range.begin_pos
         end
 
         def node_end(node)
-          node.loc.expression.end_pos
+          node.source_range.end_pos
         end
       end
     end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Detects cases where the `:foreign_key` option on associations
+      # is redundant.
+      #
+      # @example
+      #   # bad
+      #   class Post
+      #     has_many :comments, foreign_key: 'post_id'
+      #   end
+      #
+      #   class Comment
+      #     belongs_to :post, foreign_key: 'post_id'
+      #   end
+      #
+      #   # good
+      #   class Post
+      #     has_many :comments
+      #   end
+      #
+      #   class Comment
+      #     belongs_to :author, foreign_key: 'user_id'
+      #   end
+      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} $_)
+            $(hash <$(pair (sym :foreign_key) ({sym str} $_)) ...>)
+          )
+        PATTERN
+
+        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(foreign_key_pair.source_range) do |corrector|
+                range = range_with_surrounding_space(foreign_key_pair.source_range, side: :left)
+                range = range_with_surrounding_comma(range, :left)
+
+                corrector.remove(range)
+              end
+            end
+          end
+        end
+
+        private
+
+        def redundant?(node, association_type, association_name, options, foreign_key)
+          foreign_key.to_s == default_foreign_key(node, association_type, association_name, options)
+        end
+
+        def default_foreign_key(node, association_type, association_name, options)
+          if association_type == :belongs_to
+            "#{association_name}_id"
+          elsif (as = find_as_option(options))
+            "#{as}_id"
+          else
+            node.parent_module_name&.foreign_key
+          end
+        end
+
+        def find_as_option(options)
+          options.pairs.find do |pair|
+            pair.key.sym_type? && pair.key.value == :as
+          end&.value&.value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Since Rails 5.0 the default for `belongs_to` is `optional: false`
+      # unless `config.active_record.belongs_to_required_by_default` is
+      # explicitly set to `false`. The presence validator is added
+      # automatically, and explicit presence validation is redundant.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it changes the default error message
+      #   from "can't be blank" to "must exist".
+      #
+      # @example
+      #   # bad
+      #   belongs_to :user
+      #   validates :user, presence: true
+      #
+      #   # bad
+      #   belongs_to :user
+      #   validates :user_id, presence: true
+      #
+      #   # bad
+      #   belongs_to :author, foreign_key: :user_id
+      #   validates :user_id, presence: true
+      #
+      #   # good
+      #   belongs_to :user
+      #
+      #   # good
+      #   belongs_to :author, foreign_key: :user_id
+      #
+      class RedundantPresenceValidationOnBelongsTo < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Remove explicit presence validation for %<association>s.'
+        RESTRICT_ON_SEND = %i[validates].freeze
+
+        minimum_target_rails_version 5.0
+
+        # @!method presence_validation?(node)
+        #   Match a `validates` statement with a presence check
+        #
+        #   @example source that matches - by association
+        #     validates :user, presence: true
+        #
+        #   @example source that matches - by association
+        #     validates :name, :user, presence: true
+        #
+        #   @example source that matches - by a foreign key
+        #     validates :user_id, presence: true
+        #
+        #   @example source that DOES NOT match - strict validation
+        #     validates :user_id, presence: true, strict: true
+        #
+        #   @example source that DOES NOT match - custom strict validation
+        #     validates :user_id, presence: true, strict: MissingUserError
+        def_node_matcher :presence_validation?, <<~PATTERN
+          (
+            send nil? :validates
+            (sym $_)+
+            $[
+              (hash <$(pair (sym :presence) true) ...>)         # presence: true
+              !(hash <$(pair (sym :strict) {true const}) ...>)  # strict: true
+            ]
+          )
+        PATTERN
+
+        # @!method optional?(node)
+        #   Match a `belongs_to` association with an optional option in a hash
+        def_node_matcher :optional?, <<~PATTERN
+          (send nil? :belongs_to _ ... #optional_option?)
+        PATTERN
+
+        # @!method optional_option?(node)
+        #   Match an optional option in a hash
+        def_node_matcher :optional_option?, <<~PATTERN
+          {
+            (hash <(pair (sym :optional) true) ...>)   # optional: true
+            (hash <(pair (sym :required) false) ...>)  # required: false
+          }
+        PATTERN
+
+        # @!method any_belongs_to?(node, association:)
+        #   Match a class with `belongs_to` with no regard to `foreign_key` option
+        #
+        #   @example source that matches
+        #     belongs_to :user
+        #
+        #   @example source that matches - regardless of `foreign_key`
+        #     belongs_to :author, foreign_key: :user_id
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param association [Symbol]
+        #   @return [Array<RuboCop::AST::Node>, nil] matching node
+        def_node_matcher :any_belongs_to?, <<~PATTERN
+          (begin
+            <
+              $(send nil? :belongs_to (sym %association) ...)
+              ...
+            >
+          )
+        PATTERN
+
+        # @!method belongs_to?(node, key:, fk:)
+        #   Match a class with a matching association, either by name or an explicit
+        #   `foreign_key` option
+        #
+        #   @example source that matches - fk matches `foreign_key` option
+        #     belongs_to :author, foreign_key: :user_id
+        #
+        #   @example source that matches - key matches association name
+        #     belongs_to :user
+        #
+        #   @example source that does not match - explicit `foreign_key` does not match
+        #     belongs_to :user, foreign_key: :account_id
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param key [Symbol] e.g. `:user`
+        #   @param fk [Symbol] e.g. `:user_id`
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :belongs_to?, <<~PATTERN
+          (begin
+            <
+              ${
+                #belongs_to_without_fk?(%key)         # belongs_to :user
+                #belongs_to_with_a_matching_fk?(%fk)  # belongs_to :author, foreign_key: :user_id
+              }
+              ...
+            >
+          )
+        PATTERN
+
+        # @!method belongs_to_without_fk?(node, key)
+        #   Match a matching `belongs_to` association, without an explicit `foreign_key` option
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param key [Symbol] e.g. `:user`
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :belongs_to_without_fk?, <<~PATTERN
+          {
+            (send nil? :belongs_to (sym %1))        # belongs_to :user
+            (send nil? :belongs_to (sym %1) !hash ...)  # belongs_to :user, -> { not_deleted }
+            (send nil? :belongs_to (sym %1) !(hash <(pair (sym :foreign_key) _) ...>))
+          }
+        PATTERN
+
+        # @!method belongs_to_with_a_matching_fk?(node, fk)
+        #   Match a matching `belongs_to` association with a matching explicit `foreign_key` option
+        #
+        #   @example source that matches
+        #     belongs_to :author, foreign_key: :user_id
+        #
+        #   @param node [RuboCop::AST::Node]
+        #   @param fk [Symbol] e.g. `:user_id`
+        #   @return [Array<RuboCop::AST::Node>] matching nodes
+        def_node_matcher :belongs_to_with_a_matching_fk?, <<~PATTERN
+          (send nil? :belongs_to ... (hash <(pair (sym :foreign_key) (sym %1)) ...>))
+        PATTERN
+
+        def on_send(node)
+          presence_validation?(node) do |all_keys, options, presence|
+            keys = non_optional_belongs_to(node.parent, all_keys)
+            return if keys.none?
+
+            add_offense_and_correct(node, all_keys, keys, options, presence)
+          end
+        end
+
+        private
+
+        def add_offense_and_correct(node, all_keys, keys, options, presence)
+          add_offense(presence, message: message_for(keys)) do |corrector|
+            if options.children.one? # `presence: true` is the only option
+              if keys == all_keys
+                remove_validation(corrector, node)
+              else
+                remove_keys_from_validation(corrector, node, keys)
+              end
+            elsif keys == all_keys
+              remove_presence_option(corrector, presence)
+            else
+              extract_validation_for_keys(corrector, node, keys, options)
+            end
+          end
+        end
+
+        def message_for(keys)
+          display_keys = keys.map { |key| "`#{key}`" }.join('/')
+          format(MSG, association: display_keys)
+        end
+
+        def non_optional_belongs_to(node, keys)
+          keys.select do |key|
+            belongs_to = belongs_to_for(node, key)
+            belongs_to && !optional?(belongs_to)
+          end
+        end
+
+        def belongs_to_for(model_class_node, key)
+          if key.to_s.end_with?('_id')
+            normalized_key = key.to_s.delete_suffix('_id').to_sym
+            belongs_to?(model_class_node, key: normalized_key, fk: key)
+          else
+            any_belongs_to?(model_class_node, association: key)
+          end
+        end
+
+        def remove_validation(corrector, node)
+          corrector.remove(validation_range(node))
+        end
+
+        def remove_keys_from_validation(corrector, node, keys)
+          keys.each do |key|
+            key_node = node.arguments.find { |arg| arg.value == key }
+            key_range = range_with_surrounding_space(
+              range_with_surrounding_comma(key_node.source_range, :right),
+              side: :right
+            )
+            corrector.remove(key_range)
+          end
+        end
+
+        def remove_presence_option(corrector, presence)
+          range = range_with_surrounding_comma(
+            range_with_surrounding_space(presence.source_range, side: :left),
+            :left
+          )
+          corrector.remove(range)
+        end
+
+        def extract_validation_for_keys(corrector, node, keys, options)
+          indentation = ' ' * node.source_range.column
+          options_without_presence = options.children.reject { |pair| pair.key.value == :presence }
+          source = [
+            indentation,
+            'validates ',
+            keys.map(&:inspect).join(', '),
+            ', ',
+            options_without_presence.map(&:source).join(', '),
+            "\n"
+          ].join
+
+          remove_keys_from_validation(corrector, node, keys)
+          corrector.insert_after(validation_range(node), source)
+        end
+
+        def validation_range(node)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for redundant receiver in `with_options`.
+      # Checks for redundant receiver in `with_options`.
       # Receiver is implicit from Rails 4.2 or higher.
       #
       # @example
@@ -54,57 +54,59 @@ module RuboCop
       #       merger.invoke(another_receiver)
       #     end
       #   end
-      class RedundantReceiverInWithOptions < Cop
-        extend TargetRailsVersion
+      class RedundantReceiverInWithOptions < Base
         include RangeHelp
-
-        minimum_target_rails_version 4.2
+        extend AutoCorrector
 
         MSG = 'Redundant receiver in `with_options`.'
 
-        def_node_matcher :with_options?, <<-PATTERN
-          (block
-            (send nil? :with_options
-              (...))
-            (args
-              $_arg)
-            $_body)
-        PATTERN
-
-        def_node_search :all_block_nodes_in, <<-PATTERN
+        def_node_search :all_block_nodes_in, <<~PATTERN
           (block ...)
         PATTERN
 
-        def_node_search :all_send_nodes_in, <<-PATTERN
+        def_node_search :all_send_nodes_in, <<~PATTERN
           (send ...)
         PATTERN
 
         def on_block(node)
-          with_options?(node) do |arg, body|
-            return if body.nil?
-            return unless all_block_nodes_in(body).count.zero?
+          return unless node.method?(:with_options)
+          return unless (body = node.body)
+          return unless all_block_nodes_in(body).count.zero?
 
-            send_nodes = all_send_nodes_in(body)
+          send_nodes = all_send_nodes_in(body)
+          return unless redundant_receiver?(send_nodes, node)
 
-            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)
-              end
+          send_nodes.each do |send_node|
+            receiver = send_node.receiver
+            add_offense(receiver.source_range) do |corrector|
+              autocorrect(corrector, send_node, node)
             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
+        alias on_numblock on_block
 
         private
 
+        def autocorrect(corrector, send_node, node)
+          corrector.remove(send_node.receiver)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(block_argument_range(send_node)) unless node.numblock_type?
+        end
+
+        def redundant_receiver?(send_nodes, node)
+          proc = if node.numblock_type?
+                   ->(n) { n.receiver.lvar_type? && n.receiver.source == '_1' }
+                 else
+                   return false if node.arguments.empty?
+
+                   arg = node.arguments.first
+                   ->(n) { same_value?(arg, n.receiver) }
+                 end
+
+          send_nodes.all?(&proc)
+        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/redundant_travel_back.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for redundant `travel_back` calls.
+      # Since Rails 5.2, `travel_back` is automatically called at the end of the test.
+      #
+      # @example
+      #
+      #   # bad
+      #   def teardown
+      #     do_something
+      #     travel_back
+      #   end
+      #
+      #   # good
+      #   def teardown
+      #     do_something
+      #   end
+      #
+      #   # bad
+      #   after do
+      #     do_something
+      #     travel_back
+      #   end
+      #
+      #   # good
+      #   after do
+      #     do_something
+      #   end
+      #
+      class RedundantTravelBack < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.2
+
+        MSG = 'Redundant `travel_back` detected.'
+        RESTRICT_ON_SEND = %i[travel_back].freeze
+
+        def on_send(node)
+          return unless node.each_ancestor(:def, :block).any? do |ancestor|
+            method_name = ancestor.def_type? ? :teardown : :after
+
+            ancestor.method?(method_name)
+          end
+
+          add_offense(node) do |corrector|
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+          end
+        end
+      end
+    end
+  end
+end