rubocop-rails 2.15.2 → 2.20.2

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

@@ -3,58 +3,65 @@
 module RuboCop
   module Cop
     module Rails
-      # Identifies 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: 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: 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
+        extend AutoCorrector
+
         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 if dstr_separated_by_colon?(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)
+          check_for_slash_after_rails_root_in_dstr(node)
+          check_for_extension_after_rails_root_join_in_dstr(node)
         end
 
         def on_send(node)
@@ -65,11 +72,33 @@ module RuboCop
 
         private
 
+        def check_for_slash_after_rails_root_in_dstr(node)
+          rails_root_index = find_rails_root_index(node)
+          slash_node = node.children[rails_root_index + 1]
+          return unless slash_node&.str_type? && slash_node.source.start_with?(File::SEPARATOR)
+
+          register_offense(node, require_to_s: false) do |corrector|
+            autocorrect_slash_after_rails_root_in_dstr(corrector, node, rails_root_index)
+          end
+        end
+
+        def check_for_extension_after_rails_root_join_in_dstr(node)
+          rails_root_index = find_rails_root_index(node)
+          extension_node = node.children[rails_root_index + 1]
+          return unless extension_node?(extension_node)
+
+          register_offense(node, require_to_s: false) do |corrector|
+            autocorrect_extension_after_rails_root_join_in_dstr(corrector, node, rails_root_index, extension_node)
+          end
+        end
+
         def check_for_file_join_with_rails_root(node)
           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) do |corrector|
+            autocorrect_file_join(corrector, node)
+          end
         end
 
         def check_for_rails_root_join_with_string_arguments(node)
@@ -79,7 +108,9 @@ 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) do |corrector|
+            autocorrect_rails_root_join_with_string_arguments(corrector, node)
+          end
         end
 
         def check_for_rails_root_join_with_slash_separated_path(node)
@@ -88,22 +119,118 @@ 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) do |corrector|
+            autocorrect_rails_root_join_with_slash_separated_path(corrector, node)
+          end
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source.include?('/')
+          node.str_type? && node.source.include?(File::SEPARATOR)
         end
 
-        def register_offense(node)
+        def register_offense(node, require_to_s:, &block)
           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)
+
+          message = build_message(require_to_s)
+
+          add_offense(source_range, message: message, &block)
+        end
+
+        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
+
+        def dstr_separated_by_colon?(node)
+          node.children[1..].any? do |child|
+            child.str_type? && child.source.start_with?(':')
+          end
+        end
+
+        def autocorrect_slash_after_rails_root_in_dstr(corrector, node, rails_root_index)
+          rails_root_node = node.children[rails_root_index].children.first
+          argument_source = extract_rails_root_join_argument_source(node, rails_root_index)
+          if rails_root_node.method?(:join)
+            append_argument(corrector, rails_root_node, argument_source)
+          else
+            replace_with_rails_root_join(corrector, rails_root_node, argument_source)
+          end
+          node.children[rails_root_index + 1..].each { |child| corrector.remove(child) }
+        end
+
+        def autocorrect_extension_after_rails_root_join_in_dstr(corrector, node, rails_root_index, extension_node)
+          rails_root_node = node.children[rails_root_index].children.first
+          return unless rails_root_node.arguments.last.str_type?
+
+          corrector.insert_before(rails_root_node.arguments.last.location.end, extension_node.source)
+          corrector.remove(extension_node)
+        end
+
+        def autocorrect_file_join(corrector, node)
+          corrector.replace(node.receiver, 'Rails.root')
+          corrector.remove(
+            range_with_surrounding_space(
+              range_with_surrounding_comma(
+                node.arguments.first.source_range,
+                :right
+              ),
+              side: :right
+            )
+          )
+          corrector.insert_after(node, '.to_s')
+        end
+
+        def autocorrect_rails_root_join_with_string_arguments(corrector, node)
+          corrector.replace(node.arguments.first, %("#{node.arguments.map(&:value).join('/')}"))
+          node.arguments[1..].each do |argument|
+            corrector.remove(
+              range_with_surrounding_comma(
+                range_with_surrounding_space(
+                  argument.source_range,
+                  side: :left
+                ),
+                :left
+              )
+            )
+          end
+        end
+
+        def autocorrect_rails_root_join_with_slash_separated_path(corrector, node)
+          node.arguments.each do |argument|
+            next unless string_with_slash?(argument)
+
+            index = argument.source.index(File::SEPARATOR)
+            rest = inner_range_of(argument).adjust(begin_pos: index - 1)
+            corrector.remove(rest)
+            corrector.insert_after(argument, %(, "#{rest.source.delete_prefix(File::SEPARATOR)}"))
+          end
+        end
+
+        def inner_range_of(node)
+          node.location.end.with(begin_pos: node.location.begin.end_pos).adjust(end_pos: -1)
+        end
+
+        def find_rails_root_index(node)
+          node.children.index { |child| rails_root_nodes?(child) }
+        end
+
+        def append_argument(corrector, node, argument_source)
+          corrector.insert_after(node.arguments.last, %(, "#{argument_source}"))
+        end
+
+        def replace_with_rails_root_join(corrector, node, argument_source)
+          corrector.replace(node, %<Rails.root.join("#{argument_source}")>)
+        end
+
+        def extract_rails_root_join_argument_source(node, rails_root_index)
+          node.children[rails_root_index + 1..].map(&:source).join.delete_prefix(File::SEPARATOR)
         end
 
-        def message(_range)
-          format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
+        def extension_node?(node)
+          node&.str_type? && node.source.start_with?('.')
         end
       end
     end

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

@@ -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
-      # Identifies 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,18 +17,24 @@ 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`.'
         RESTRICT_ON_SEND = %i[each].freeze
 
         SCOPE_METHODS = %i[
-          all eager_load includes joins left_joins left_outer_joins not preload
+          all eager_load includes joins left_joins left_outer_joins not or preload
           references unscoped where
         ].freeze
 
@@ -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_many_or_has_one_dependent.rb

@@ -37,15 +37,15 @@ module RuboCop
         RESTRICT_ON_SEND = %i[has_many has_one].freeze
 
         def_node_search :active_resource_class?, <<~PATTERN
-          (const (const nil? :ActiveResource) :Base)
+          (const (const {nil? cbase} :ActiveResource) :Base)
         PATTERN
 
         def_node_matcher :association_without_options?, <<~PATTERN
-          (send nil? {:has_many :has_one} _)
+          (send _ {:has_many :has_one} _)
         PATTERN
 
         def_node_matcher :association_with_options?, <<~PATTERN
-          (send nil? {:has_many :has_one} ... (hash $...))
+          (send _ {:has_many :has_one} ... (hash $...))
         PATTERN
 
         def_node_matcher :dependent_option?, <<~PATTERN
@@ -105,9 +105,7 @@ module RuboCop
 
             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

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

@@ -37,7 +37,7 @@ module RuboCop
         def_node_matcher :form_builder_class?, <<~PATTERN
           (const
             (const
-               (const nil? :ActionView) :Helpers) :FormBuilder)
+               (const {nil? cbase} :ActionView) :Helpers) :FormBuilder)
         PATTERN
 
         def on_ivar(node)

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

@@ -10,6 +10,9 @@ module RuboCop
       # Rails/HttpPositionalArguments cop or set your TargetRailsVersion in your
       # .rubocop.yml file to 4.2.
       #
+      # NOTE: It does not detect any cases where `include Rack::Test::Methods` is used
+      # which makes the http methods incompatible behavior.
+      #
       # @example
       #   # bad
       #   get :new, { user_id: 1}
@@ -22,11 +25,8 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%<verb>s`.'
-        KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env to
-        ].freeze
+        MSG = 'Use keyword arguments instead of positional arguments for http call: `%<verb>s`.'
+        KEYWORD_ARGS = %i[method params session body flash xhr as headers env to].freeze
         ROUTING_METHODS = %i[draw routes].freeze
         RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
 
@@ -40,8 +40,15 @@ module RuboCop
           (hash (kwsplat _))
         PATTERN
 
+        def_node_matcher :include_rack_test_methods?, <<~PATTERN
+          (send nil? :include
+            (const
+              (const
+                (const {nil? cbase} :Rack) :Test) :Methods))
+        PATTERN
+
         def on_send(node)
-          return if in_routing_block?(node)
+          return if in_routing_block?(node) || use_rack_test_methods?
 
           http_request?(node) do |data|
             return unless needs_conversion?(data)
@@ -59,7 +66,7 @@ module RuboCop
               # 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))
+              corrector.replace(node, correction(node))
             end
           end
         end
@@ -70,13 +77,18 @@ module RuboCop
           !!node.each_ancestor(:block).detect { |block| ROUTING_METHODS.include?(block.method_name) }
         end
 
+        def use_rack_test_methods?
+          processed_source.ast.each_descendant(:send).any? do |node|
+            include_rack_test_methods?(node)
+          end
+        end
+
         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) ||
-              (format_arg?(pair.key) && data.pairs.one?)
+            special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
           end
         end
 
@@ -98,8 +110,7 @@ module RuboCop
           return '' if data.hash_type? && data.empty?
 
           hash_data = if data.hash_type?
-                        format('{ %<data>s }',
-                               data: data.pairs.map(&:source).join(', '))
+                        format('{ %<data>s }', data: data.pairs.map(&:source).join(', '))
                       else
                         # user supplies an object,
                         # no need to surround with braces

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

@@ -66,7 +66,7 @@ module RuboCop
             return unless checker.offensive?
 
             add_offense(checker.node, message: checker.message) do |corrector|
-              corrector.replace(checker.node.loc.expression, checker.preferred_style)
+              corrector.replace(checker.node, checker.preferred_style)
             end
           end
         end
@@ -84,10 +84,8 @@ module RuboCop
 
         # :nodoc:
         class SymbolicStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` to define HTTP status code.'
 
           attr_reader :node
 
@@ -118,17 +116,14 @@ module RuboCop
           end
 
           def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
+            node.int_type? && !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
           end
         end
 
         # :nodoc:
         class NumericStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` to define HTTP status code.'
           PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node

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

@@ -34,6 +34,8 @@ module RuboCop
 
         MSG = 'Use "lazy" lookup for the text used in controllers.'
 
+        RESTRICT_ON_SEND = %i[translate t].freeze
+
         def_node_matcher :translate_call?, <<~PATTERN
           (send nil? {:translate :t} ${sym_type? str_type?} ...)
         PATTERN

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

@@ -69,7 +69,7 @@ module RuboCop
       class I18nLocaleTexts < Base
         MSG = 'Move locale texts to the locale files in the `config/locales` directory.'
 
-        RESTRICT_ON_SEND = %i[validates redirect_to []= mail].freeze
+        RESTRICT_ON_SEND = %i[validates redirect_to redirect_back []= mail].freeze
 
         def_node_search :validation_message, <<~PATTERN
           (pair (sym :message) $str)
@@ -80,7 +80,11 @@ module RuboCop
         PATTERN
 
         def_node_matcher :flash_assignment?, <<~PATTERN
-          (send (send nil? :flash) :[]= _ $str)
+          (send
+            {
+              (send nil? :flash)
+              (send (send nil? :flash) :now)
+            } :[]= _ $str)
         PATTERN
 
         def_node_search :mail_subject, <<~PATTERN
@@ -94,7 +98,7 @@ module RuboCop
               add_offense(text_node)
             end
             return
-          when :redirect_to
+          when :redirect_to, :redirect_back
             text_node = redirect_to_flash(node).to_a.last
           when :[]=
             text_node = flash_assignment?(node)

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for assignments of `ignored_columns` that may override previous
+      # assignments.
+      #
+      # Overwriting previous assignments is usually a mistake, since it will
+      # un-ignore the first set of columns. Since duplicate column names is not
+      # a problem, it is better to simply append to the list.
+      #
+      # @example
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one]
+      #   end
+      #
+      #   # bad
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns = [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one, :two]
+      #   end
+      #
+      #   # good
+      #   class User < ActiveRecord::Base
+      #     self.ignored_columns += [:one]
+      #     self.ignored_columns += [:two]
+      #   end
+      #
+      class IgnoredColumnsAssignment < Base
+        extend AutoCorrector
+
+        MSG = 'Use `+=` instead of `=`.'
+        RESTRICT_ON_SEND = %i[ignored_columns=].freeze
+
+        def on_send(node)
+          add_offense(node.loc.operator) do |corrector|
+            corrector.replace(node.loc.operator, '+=')
+          end
+        end
+      end
+    end
+  end
+end