rubocop-rails 2.0.1 → 2.19.1

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

@@ -3,51 +3,70 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of `where.first` and
-      # change them to use `find_by` instead.
+      # Identifies usages of `where.take` and change them to use `find_by` instead.
+      #
+      # And `where(...).first` can return different results from `find_by`.
+      # (They order records differently, so the "first" record can be different.)
+      #
+      # If you also want to detect `where.first`, you can set `IgnoreWhereFirst` to false.
       #
       # @example
       #   # bad
-      #   User.where(name: 'Bruce').first
       #   User.where(name: 'Bruce').take
       #
       #   # good
       #   User.find_by(name: 'Bruce')
-      class FindBy < Cop
+      #
+      # @example IgnoreWhereFirst: true (default)
+      #   # good
+      #   User.where(name: 'Bruce').first
+      #
+      # @example IgnoreWhereFirst: false
+      #   # bad
+      #   User.where(name: 'Bruce').first
+      class FindBy < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `find_by` instead of `where.%<method>s`.'
-        TARGET_SELECTORS = %i[first take].freeze
-
-        def_node_matcher :where_first?, <<-PATTERN
-          (send ({send csend} _ :where ...) {:first :take})
-        PATTERN
+        RESTRICT_ON_SEND = %i[first take].freeze
 
         def on_send(node)
-          return unless where_first?(node)
+          return unless node.arguments.empty? && where_method?(node.receiver)
+          return if ignore_where_first? && node.method?(:first)
 
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.loc.selector.end_pos)
+          range = offense_range(node)
 
-          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)
-          # 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.)
+        private
+
+        def where_method?(receiver)
+          return false unless receiver
+
+          receiver.respond_to?(:method?) && receiver.method?(:where)
+        end
+
+        def offense_range(node)
+          range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
+        end
+
+        def autocorrect(corrector, node)
           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
+
+        def ignore_where_first?
+          cop_config.fetch('IgnoreWhereFirst', true)
         end
       end
     end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces that `ActiveRecord#find` is used instead of
+      # `where.take!`, `find_by!`, and `find_by_id!` to retrieve a single record
+      # by primary key when you expect it to be found.
+      #
+      # @example
+      #   # bad
+      #   User.where(id: id).take!
+      #   User.find_by_id!(id)
+      #   User.find_by!(id: id)
+      #
+      #   # good
+      #   User.find(id)
+      #
+      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
+            $(send _ :where
+              (hash
+                (pair (sym :id) $_))) :take!)
+        PATTERN
+
+        def_node_matcher :find_by?, <<~PATTERN
+          {
+            (send _ :find_by_id! $_)
+            (send _ :find_by! (hash (pair (sym :id) $_)))
+          }
+        PATTERN
+
+        def on_send(node)
+          where_take?(node) do |where, id_value|
+            range = where_take_offense_range(node, where)
+            bad_method = build_where_take_bad_method(id_value)
+
+            register_offense(range, id_value, bad_method)
+          end
+
+          find_by?(node) do |id_value|
+            range = find_by_offense_range(node)
+            bad_method = build_find_by_bad_method(node, id_value)
+
+            register_offense(range, id_value, bad_method)
+          end
+        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)
+
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, good_method)
+          end
+        end
+
+        def where_take_offense_range(node, where)
+          range_between(where.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+
+        def find_by_offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+
+        def build_good_method(id_value)
+          "find(#{id_value.source})"
+        end
+
+        def build_where_take_bad_method(id_value)
+          "where(id: #{id_value.source}).take!"
+        end
+
+        def build_find_by_bad_method(node, id_value)
+          case node.method_name
+          when :find_by_id!
+            "find_by_id!(#{id_value.source})"
+          when :find_by!
+            "find_by!(id: #{id_value.source})"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,8 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of `all.each` and
-      # change them to use `all.find_each` instead.
+      # Identifies usages of `all.each` and change them to use `all.find_each` instead.
+      #
+      # @safety
+      #   This cop is unsafe if the receiver object is not an Active Record object.
+      #   Also, `all.each` returns an `Array` instance and `all.find_each` returns nil,
+      #   so the return values are different.
       #
       # @example
       #   # bad
@@ -12,38 +16,58 @@ module RuboCop
       #
       #   # good
       #   User.all.find_each
-      class FindEach < Cop
+      #
+      # @example AllowedMethods: ['order']
+      #   # good
+      #   User.order(:foo).each
+      #
+      # @example AllowedPattern: ['order']
+      #   # good
+      #   User.order(:foo).each
+      class FindEach < Base
+        include ActiveRecordHelper
+        include AllowedMethods
+        include AllowedPattern
+        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)
+        def ignored?(node)
+          return true if active_model_error_where?(node.receiver)
+
+          method_chain = node.each_node(:send).map(&:method_name)
+
+          method_chain.any? { |method_name| allowed_method?(method_name) || matches_allowed_pattern?(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 active_model_error_where?(node)
+          node.method?(:where) && active_model_error?(node.receiver)
+        end
+
+        def active_model_error?(node)
+          return false if node.nil?
+
+          node.send_type? && node.method?(:errors)
         end
       end
     end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies usages of `travel_to` with an argument of the current time and
+      # change them to use `freeze_time` instead.
+      #
+      # @safety
+      #   This cop’s autocorrection is unsafe because `freeze_time` just delegates to
+      #   `travel_to` with a default `Time.now`, it is not strictly equivalent to `Time.now`
+      #   if the argument of `travel_to` is the current time considering time zone.
+      #
+      # @example
+      #   # bad
+      #   travel_to(Time.now)
+      #   travel_to(Time.new)
+      #   travel_to(DateTime.now)
+      #   travel_to(Time.current)
+      #   travel_to(Time.zone.now)
+      #   travel_to(Time.now.in_time_zone)
+      #   travel_to(Time.current.to_time)
+      #
+      #   # good
+      #   freeze_time
+      #
+      class FreezeTime < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 5.2
+
+        MSG = 'Use `freeze_time` instead of `travel_to`.'
+        NOW_METHODS = %i[now new current].freeze
+        CONVERT_METHODS = %i[to_time in_time_zone].freeze
+        RESTRICT_ON_SEND = %i[travel_to].freeze
+
+        # @!method time_now?(node)
+        def_node_matcher :time_now?, <<~PATTERN
+          (const {nil? cbase} {:Time :DateTime})
+        PATTERN
+
+        # @!method zoned_time_now?(node)
+        def_node_matcher :zoned_time_now?, <<~PATTERN
+          (send (const {nil? cbase} :Time) :zone)
+        PATTERN
+
+        def on_send(node)
+          child_node, method_name, time_argument = *node.first_argument&.children
+          return if time_argument || !child_node
+          return unless current_time?(child_node, method_name) || current_time_with_convert?(child_node, method_name)
+
+          add_offense(node) do |corrector|
+            last_argument = node.last_argument
+            freeze_time_method = last_argument.block_pass_type? ? "freeze_time(#{last_argument.source})" : 'freeze_time'
+            corrector.replace(node, freeze_time_method)
+          end
+        end
+
+        private
+
+        def current_time?(node, method_name)
+          return false unless NOW_METHODS.include?(method_name)
+
+          node.send_type? ? zoned_time_now?(node) : time_now?(node)
+        end
+
+        def current_time_with_convert?(node, method_name)
+          return false unless CONVERT_METHODS.include?(method_name)
+
+          child_node, child_method_name, time_argument = *node.children
+          return if time_argument
+
+          current_time?(child_node, child_method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of the has_and_belongs_to_many macro.
+      # Checks for the use of the has_and_belongs_to_many macro.
       #
       # @example
       #   # bad
@@ -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

@@ -3,9 +3,11 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for `has_many` or `has_one` associations that don't
+      # 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,75 +20,102 @@ 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)
+        def_node_search :active_resource_class?, <<~PATTERN
+          (const (const {nil? cbase} :ActiveResource) :Base)
         PATTERN
 
-        def_node_matcher :association_without_options?, <<-PATTERN
-          (send nil? {:has_many :has_one} _)
+        def_node_matcher :association_without_options?, <<~PATTERN
+          (send _ {:has_many :has_one} _)
         PATTERN
 
-        def_node_matcher :association_with_options?, <<-PATTERN
-          (send nil? {:has_many :has_one} _ (hash $...))
+        def_node_matcher :association_with_options?, <<~PATTERN
+          (send _ {:has_many :has_one} ... (hash $...))
         PATTERN
 
-        def_node_matcher :dependent_option?, <<-PATTERN
-          (pair (sym :dependent) !nil)
+        def_node_matcher :dependent_option?, <<~PATTERN
+          (pair (sym :dependent) {!nil (nil)})
         PATTERN
 
-        def_node_matcher :present_option?, <<-PATTERN
+        def_node_matcher :present_option?, <<~PATTERN
           (pair (sym :through) !nil)
         PATTERN
 
-        def_node_matcher :with_options_block, <<-PATTERN
+        def_node_matcher :with_options_block, <<~PATTERN
           (block
             (send nil? :with_options
               (hash $...))
             (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
 
         def contain_valid_options_in_with_options_block?(node)
-          if with_options_block(node)
-            return true if valid_options?(with_options_block(node))
+          if (options = with_options_block(node))
+            return true if valid_options?(options)
 
             return false unless node.parent
 
-            return true if contain_valid_options_in_with_options_block?(
-              node.parent.parent
-            )
+            return true if contain_valid_options_in_with_options_block?(node.parent.parent)
           end
 
           false
         end
 
         def valid_options?(options)
+          return false if options.nil?
+
+          options = extract_option_if_kwsplat(options)
+
           return true unless options
           return true if options.any? do |o|
             dependent_option?(o) || present_option?(o)
@@ -95,6 +124,14 @@ module RuboCop
           false
         end
 
+        def extract_option_if_kwsplat(options)
+          if options.first.kwsplat_type? && options.first.children.first.hash_type?
+            return options.first.children.first.pairs
+          end
+
+          options
+        end
+
         def active_resource?(node)
           return false if node.nil?
 

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

@@ -3,16 +3,19 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for use of the helper methods which reference
+      # Checks for use of the helper methods which reference
       # instance variables.
       #
       # Relying on instance variables makes it difficult to re-use helper
       # methods.
       #
       # If it seems awkward to explicitly pass in each dependent
-      # variable, consider moving the behaviour elsewhere, for
+      # variable, consider moving the behavior 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? cbase} :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