rubocop-rails 2.14.2 → 2.19.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks dynamic `find_by_*` methods.
+      # Checks dynamic `find_by_*` methods.
       # Use `find_by` instead of dynamic method.
       # See. https://rails.rubystyle.guide#find_by
       #
@@ -22,19 +22,23 @@ module RuboCop
       #   User.find_by(name: name, email: email)
       #   User.find_by!(email: email)
       #
-      # @example AllowedMethods: find_by_sql
+      # @example AllowedMethods: ['find_by_sql', 'find_by_token_for'] (default)
       #   # bad
       #   User.find_by_query(users_query)
+      #   User.find_by_token_for(:password_reset, token)
       #
       #   # good
       #   User.find_by_sql(users_sql)
+      #   User.find_by_token_for(:password_reset, token)
       #
-      # @example AllowedReceivers: Gem::Specification
+      # @example AllowedReceivers: ['Gem::Specification', 'page'] (default)
       #   # bad
       #   Specification.find_by_name('backend').gem_dir
+      #   page.find_by_id('a_dom_id').click
       #
       #   # good
       #   Gem::Specification.find_by_name('backend').gem_dir
+      #   page.find_by_id('a_dom_id').click
       class DynamicFindBy < Base
         include ActiveRecordHelper
         extend AutoCorrector
@@ -49,7 +53,7 @@ module RuboCop
           method_name = node.method_name
           static_name = static_method_name(method_name)
           return unless static_name
-          return if node.arguments.any? { |argument| IGNORED_ARGUMENT_TYPES.include?(argument.type) }
+          return unless dynamic_find_by_arguments?(node)
 
           message = format(MSG, static_name: static_name, method: method_name)
           add_offense(node, message: message) do |corrector|
@@ -61,17 +65,12 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          keywords = column_keywords(node.method_name)
-
-          return if keywords.size != node.arguments.size
-
           autocorrect_method_name(corrector, node)
-          autocorrect_argument_keywords(corrector, node, keywords)
+          autocorrect_argument_keywords(corrector, node, column_keywords(node.method_name))
         end
 
         def allowed_invocation?(node)
-          allowed_method?(node) || allowed_receiver?(node) ||
-            whitelisted?(node)
+          allowed_method?(node) || allowed_receiver?(node) || whitelisted?(node)
         end
 
         def allowed_method?(node)
@@ -95,13 +94,12 @@ module RuboCop
         end
 
         def autocorrect_method_name(corrector, node)
-          corrector.replace(node.loc.selector,
-                            static_method_name(node.method_name.to_s))
+          corrector.replace(node.loc.selector, static_method_name(node.method_name.to_s))
         end
 
         def autocorrect_argument_keywords(corrector, node, keywords)
           keywords.each.with_index do |keyword, idx|
-            corrector.insert_before(node.arguments[idx].loc.expression, keyword)
+            corrector.insert_before(node.arguments[idx], keyword)
           end
         end
 
@@ -118,6 +116,20 @@ module RuboCop
 
           match[2] ? 'find_by!' : 'find_by'
         end
+
+        def dynamic_find_by_arguments?(node)
+          dynamic_find_by_arguments_count?(node) && dynamic_find_by_arguments_type?(node)
+        end
+
+        def dynamic_find_by_arguments_count?(node)
+          column_keywords(node.method_name).size == node.arguments.size
+        end
+
+        def dynamic_find_by_arguments_type?(node)
+          node.arguments.none? do |argument|
+            IGNORED_ARGUMENT_TYPES.include?(argument.type)
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that blocks are used for interpolated strings passed to
+      # Checks that blocks are used for interpolated strings passed to
       # `Rails.logger.debug`.
       #
       # By default, Rails production environments use the `:info` log level.
@@ -37,6 +37,10 @@ module RuboCop
           )
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if node.parent&.block_type?
 
@@ -55,7 +59,7 @@ module RuboCop
         private
 
         def replacement_range(node)
-          stop = node.loc.expression.end
+          stop = node.source_range.end
           start = node.loc.selector.end
 
           if node.parenthesized_call?

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for enums written with array syntax.
+      # Looks for enums written with array syntax.
       #
       # When using array syntax, adding an element in a
       # position other than the last causes all previous
@@ -20,8 +20,7 @@ module RuboCop
       class EnumHash < Base
         extend AutoCorrector
 
-        MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. '\
-              'Use hash syntax instead.'
+        MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. Use hash syntax instead.'
         RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
@@ -43,7 +42,7 @@ module RuboCop
                   "#{source(elem)} => #{index}"
                 end.join(', ')
 
-                corrector.replace(array.loc.expression, "{#{hash}}")
+                corrector.replace(array, "{#{hash}}")
               end
             end
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for duplicate values in enum declarations.
+      # Looks for duplicate values in enum declarations.
       #
       # @example
       #   # bad
@@ -20,8 +20,7 @@ module RuboCop
       class EnumUniqueness < Base
         include Duplication
 
-        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
-              'enum declaration.'
+        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` enum declaration.'
         RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
@@ -41,9 +40,7 @@ module RuboCop
                 next unless duplicates?(items)
 
                 consecutive_duplicates(items).each do |item|
-                  add_offense(item, message: format(
-                    MSG, value: item.source, enum: enum_name(key)
-                  ))
+                  add_offense(item, message: format(MSG, value: item.source, enum: enum_name(key)))
                 end
               end
             end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that Rails.env is compared using `.production?`-like
+      # Checks that Rails.env is compared using `.production?`-like
       # methods instead of equality against a string or symbol.
       #
       # @example
@@ -84,7 +84,7 @@ module RuboCop
         def autocorrect(corrector, node)
           replacement = build_predicate_method(node)
 
-          corrector.replace(node.source_range, replacement)
+          corrector.replace(node, replacement)
         end
 
         def build_predicate_method(node)
@@ -96,8 +96,7 @@ module RuboCop
         end
 
         def rails_env_on_lhs?(node)
-          comparing_str_env_with_rails_env_on_lhs?(node) ||
-            comparing_sym_env_with_rails_env_on_lhs?(node)
+          comparing_str_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_lhs?(node)
         end
 
         def build_predicate_method_for_rails_env_on_lhs(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for direct access to environment variables through the
+      # Looks for direct access to environment variables through the
       # `ENV` variable within the application code. This can lead to runtime
       # errors due to misconfiguration that could have been discovered at boot
       # time if the environment variables were loaded as part of initialization

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces that `exit` calls are not used within a rails app.
+      # Enforces that `exit` calls are not used within a rails app.
       # Valid options are instead to raise an error, break, return, or some
       # other form of stopping execution of current request.
       #

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for expanded date range. It only compatible `..` range is targeted.
+      # Checks for expanded date range. It only compatible `..` range is targeted.
       # Incompatible `...` range is ignored.
       #
       # @example
@@ -29,14 +29,6 @@ module RuboCop
 
         minimum_target_rails_version 5.1
 
-        def_node_matcher :expanded_date_range, <<~PATTERN
-          (irange
-            (send
-              $_ {:beginning_of_day :beginning_of_week :beginning_of_month :beginning_of_quarter :beginning_of_year})
-            (send
-              $_ {:end_of_day :end_of_week :end_of_month :end_of_quarter :end_of_year}))
-        PATTERN
-
         PREFERRED_METHODS = {
           beginning_of_day: 'all_day',
           beginning_of_week: 'all_week',
@@ -54,31 +46,55 @@ module RuboCop
         }.freeze
 
         def on_irange(node)
-          return unless expanded_date_range(node)
-
           begin_node = node.begin
           end_node = node.end
-          return unless same_receiver?(begin_node, end_node)
-
-          beginning_method = begin_node.method_name
-          end_method = end_node.method_name
-          return unless use_mapped_methods?(beginning_method, end_method)
+          return if allow?(begin_node, end_node)
 
-          preferred_method = "#{begin_node.receiver.source}.#{PREFERRED_METHODS[beginning_method]}"
+          preferred_method = preferred_method(begin_node)
+          if begin_node.method?(:beginning_of_week) && begin_node.arguments.one?
+            return unless same_argument?(begin_node, end_node)
 
-          add_offense(node, message: format(MSG, preferred_method: preferred_method)) do |corrector|
-            corrector.replace(node, preferred_method)
+            preferred_method << "(#{begin_node.first_argument.source})"
+          elsif any_arguments?(begin_node, end_node)
+            return
           end
+
+          register_offense(node, preferred_method)
         end
 
         private
 
-        def same_receiver?(begin_node, end_node)
-          begin_node.receiver.source == end_node.receiver.source
+        def allow?(begin_node, end_node)
+          return true unless (begin_source = receiver_source(begin_node))
+          return true unless (end_source = receiver_source(end_node))
+
+          begin_source != end_source || MAPPED_DATE_RANGE_METHODS[begin_node.method_name] != end_node.method_name
+        end
+
+        def receiver_source(node)
+          return if !node&.send_type? || node.receiver.nil?
+
+          node.receiver.source
         end
 
-        def use_mapped_methods?(beginning_method, end_method)
-          MAPPED_DATE_RANGE_METHODS[beginning_method] == end_method
+        def same_argument?(begin_node, end_node)
+          begin_node.first_argument.source == end_node.first_argument.source
+        end
+
+        def preferred_method(begin_node)
+          +"#{begin_node.receiver.source}.#{PREFERRED_METHODS[begin_node.method_name]}"
+        end
+
+        def any_arguments?(begin_node, end_node)
+          begin_node.arguments.any? || end_node.arguments.any?
+        end
+
+        def register_offense(node, preferred_method)
+          message = format(MSG, preferred_method: preferred_method)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, preferred_method)
+          end
         end
       end
     end

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

@@ -3,55 +3,66 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of file path joining process
-      # to use `Rails.root.join` clause. It is used to add uniformity when
-      # joining paths.
+      # Identifies usages of file path joining process to use `Rails.root.join` clause.
+      # It is used to add uniformity when joining paths.
       #
-      # @example EnforcedStyle: arguments
+      # @example EnforcedStyle: slashes (default)
       #   # bad
+      #   Rails.root.join('app', 'models', 'goober')
+      #
+      #   # good
       #   Rails.root.join('app/models/goober')
+      #
+      #   # bad
       #   File.join(Rails.root, 'app/models/goober')
       #   "#{Rails.root}/app/models/goober"
       #
       #   # good
-      #   Rails.root.join('app', 'models', 'goober')
+      #   Rails.root.join('app/models/goober').to_s
       #
-      # @example EnforcedStyle: slashes (default)
+      # @example EnforcedStyle: arguments
       #   # bad
+      #   Rails.root.join('app/models/goober')
+      #
+      #   # good
       #   Rails.root.join('app', 'models', 'goober')
+      #
+      #   # bad
       #   File.join(Rails.root, 'app/models/goober')
       #   "#{Rails.root}/app/models/goober"
       #
       #   # good
-      #   Rails.root.join('app/models/goober')
+      #   Rails.root.join('app', 'models', 'goober').to_s
       #
       class FilePath < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')`.'
-        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')`.'
+        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')%<to_s>s`.'
+        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')%<to_s>s`.'
         RESTRICT_ON_SEND = %i[join].freeze
 
         def_node_matcher :file_join_nodes?, <<~PATTERN
-          (send (const nil? :File) :join ...)
+          (send (const {nil? cbase} :File) :join ...)
         PATTERN
 
         def_node_search :rails_root_nodes?, <<~PATTERN
-          (send (const nil? :Rails) :root)
+          (send (const {nil? cbase} :Rails) :root)
         PATTERN
 
         def_node_matcher :rails_root_join_nodes?, <<~PATTERN
-          (send (send (const nil? :Rails) :root) :join ...)
+          (send #rails_root_nodes? :join ...)
         PATTERN
 
         def on_dstr(node)
           return unless rails_root_nodes?(node)
           return unless node.children.last.str_type?
-          return unless node.children.last.source.start_with?('.') ||
-                        node.children.last.source.include?(File::SEPARATOR)
 
-          register_offense(node)
+          last_child_source = node.children.last.source
+          return unless last_child_source.start_with?('.') || last_child_source.include?(File::SEPARATOR)
+          return if last_child_source.start_with?(':')
+
+          register_offense(node, require_to_s: true)
         end
 
         def on_send(node)
@@ -66,7 +77,7 @@ module RuboCop
           return unless file_join_nodes?(node)
           return unless node.arguments.any? { |e| rails_root_nodes?(e) }
 
-          register_offense(node)
+          register_offense(node, require_to_s: true)
         end
 
         def check_for_rails_root_join_with_string_arguments(node)
@@ -76,7 +87,7 @@ module RuboCop
           return unless node.arguments.size > 1
           return unless node.arguments.all?(&:str_type?)
 
-          register_offense(node)
+          register_offense(node, require_to_s: false)
         end
 
         def check_for_rails_root_join_with_slash_separated_path(node)
@@ -85,22 +96,28 @@ module RuboCop
           return unless rails_root_join_nodes?(node)
           return unless node.arguments.any? { |arg| string_with_slash?(arg) }
 
-          register_offense(node)
+          register_offense(node, require_to_s: false)
         end
 
         def string_with_slash?(node)
           node.str_type? && node.source.include?('/')
         end
 
-        def register_offense(node)
+        def register_offense(node, require_to_s:)
           line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.first_line,
-                                      line_range)
-          add_offense(source_range)
+          source_range = source_range(processed_source.buffer, node.first_line, line_range)
+          require_to_s = false if node.dstr_type?
+
+          message = build_message(require_to_s)
+
+          add_offense(source_range, message: message)
         end
 
-        def message(_range)
-          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
+        def build_message(require_to_s)
+          message_template = style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES
+          to_s = require_to_s ? '.to_s' : ''
+
+          format(message_template, to_s: to_s)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop is used to identify usages of `where.take` 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.)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces that `ActiveRecord#find` is used instead of
+      # 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.
       #
@@ -65,11 +65,11 @@ module RuboCop
         end
 
         def where_take_offense_range(node, where)
-          range_between(where.loc.selector.begin_pos, node.loc.expression.end_pos)
+          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.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def build_good_method(id_value)

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
@@ -13,11 +17,17 @@ module RuboCop
       #   # good
       #   User.all.find_each
       #
-      # @example IgnoredMethods: ['order']
+      # @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`.'
@@ -47,7 +57,7 @@ module RuboCop
 
           method_chain = node.each_node(:send).map(&:method_name)
 
-          (cop_config['IgnoredMethods'].map(&:to_sym) & method_chain).any?
+          method_chain.any? { |method_name| allowed_method?(method_name) || matches_allowed_pattern?(method_name) }
         end
 
         def active_model_error_where?(node)

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