rubocop-rails 2.19.1 → 2.30.3

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

@@ -6,6 +6,9 @@ module RuboCop
       # Identifies usages of file path joining process to use `Rails.root.join` clause.
       # It is used to add uniformity when joining paths.
       #
+      # NOTE: This cop ignores leading slashes in string literal arguments for `Rails.root.join`
+      #       and multiple slashes in string literal arguments for `Rails.root.join` and `File.join`.
+      #
       # @example EnforcedStyle: slashes (default)
       #   # bad
       #   Rails.root.join('app', 'models', 'goober')
@@ -35,6 +38,8 @@ module RuboCop
       #   Rails.root.join('app', 'models', 'goober').to_s
       #
       class FilePath < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
         include RangeHelp
 
@@ -56,61 +61,112 @@ module RuboCop
 
         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, require_to_s: true)
+          check_for_slash_after_rails_root_in_dstr(node)
+          check_for_extension_after_rails_root_join_in_dstr(node)
         end
 
         def on_send(node)
           check_for_file_join_with_rails_root(node)
+          return unless node.receiver
+
           check_for_rails_root_join_with_slash_separated_path(node)
           check_for_rails_root_join_with_string_arguments(node)
         end
 
         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)
+          return unless node.children[rails_root_index].children.first.send_type?
+
+          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) }
+          return unless valid_arguments_for_file_join_with_rails_root?(node.arguments)
 
-          register_offense(node, require_to_s: true)
+          register_offense(node, require_to_s: true) do |corrector|
+            autocorrect_file_join(corrector, node) unless node.first_argument.array_type?
+          end
         end
 
         def check_for_rails_root_join_with_string_arguments(node)
           return unless style == :slashes
           return unless rails_root_nodes?(node)
           return unless rails_root_join_nodes?(node)
-          return unless node.arguments.size > 1
-          return unless node.arguments.all?(&:str_type?)
+          return unless valid_string_arguments_for_rails_root_join?(node.arguments)
 
-          register_offense(node, require_to_s: false)
+          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)
           return unless style == :arguments
           return unless rails_root_nodes?(node)
           return unless rails_root_join_nodes?(node)
-          return unless node.arguments.any? { |arg| string_with_slash?(arg) }
+          return unless valid_slash_separated_path_for_rails_root_join?(node.arguments)
 
-          register_offense(node, require_to_s: false)
+          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?('/')
+        def valid_arguments_for_file_join_with_rails_root?(arguments)
+          return false unless arguments.any? { |arg| rails_root_nodes?(arg) }
+
+          arguments.none? { |arg| arg.variable? || arg.const_type? || string_contains_multiple_slashes?(arg) }
         end
 
-        def register_offense(node, require_to_s:)
+        def valid_string_arguments_for_rails_root_join?(arguments)
+          return false unless arguments.size > 1
+          return false unless arguments.all?(&:str_type?)
+
+          arguments.none? { |arg| string_with_leading_slash?(arg) || string_contains_multiple_slashes?(arg) }
+        end
+
+        def valid_slash_separated_path_for_rails_root_join?(arguments)
+          return false unless arguments.any? { |arg| string_contains_slash?(arg) }
+
+          arguments.none? { |arg| string_with_leading_slash?(arg) || string_contains_multiple_slashes?(arg) }
+        end
+
+        def string_contains_slash?(node)
+          node.str_type? && node.value.include?(File::SEPARATOR)
+        end
+
+        def string_contains_multiple_slashes?(node)
+          node.str_type? && node.value.include?('//')
+        end
+
+        def string_with_leading_slash?(node)
+          node.str_type? && node.value.start_with?(File::SEPARATOR)
+        end
+
+        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)
-          require_to_s = false if node.dstr_type?
 
           message = build_message(require_to_s)
 
-          add_offense(source_range, message: message)
+          add_offense(source_range, message: message, &block)
         end
 
         def build_message(require_to_s)
@@ -119,6 +175,118 @@ module RuboCop
 
           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.last_argument.str_type?
+
+          corrector.insert_before(rails_root_node.last_argument.location.end, extension_node.source)
+          corrector.remove(extension_node)
+        end
+
+        def autocorrect_file_join(corrector, node)
+          replace_receiver_with_rails_root(corrector, node)
+          remove_first_argument_with_comma(corrector, node)
+          process_arguments(corrector, node.arguments)
+          append_to_string_conversion(corrector, node)
+        end
+
+        def replace_receiver_with_rails_root(corrector, node)
+          corrector.replace(node.receiver, 'Rails.root')
+        end
+
+        def remove_first_argument_with_comma(corrector, node)
+          corrector.remove(
+            range_with_surrounding_space(
+              range_with_surrounding_comma(
+                node.first_argument.source_range,
+                :right
+              ),
+              side: :right
+            )
+          )
+        end
+
+        def process_arguments(corrector, arguments)
+          arguments.each do |argument|
+            if argument.str_type?
+              corrector.replace(argument, argument.value.delete_prefix('/').inspect)
+            elsif argument.array_type?
+              corrector.replace(argument, "*#{argument.source}")
+            end
+          end
+        end
+
+        def append_to_string_conversion(corrector, node)
+          corrector.insert_after(node, '.to_s')
+        end
+
+        def autocorrect_rails_root_join_with_string_arguments(corrector, node)
+          corrector.replace(node.first_argument, %("#{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_contains_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.last_argument, %(, "#{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 extension_node?(node)
+          node&.str_type? && node.source.match?(/\A\.[A-Za-z]+/)
+        end
       end
     end
   end

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

@@ -28,7 +28,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Use `find_by` instead of `where.%<method>s`.'
+        MSG = 'Use `find_by` instead of `where%<dot>s%<method>s`.'
         RESTRICT_ON_SEND = %i[first take].freeze
 
         def on_send(node)
@@ -37,7 +37,7 @@ module RuboCop
 
           range = offense_range(node)
 
-          add_offense(range, message: format(MSG, method: node.method_name)) do |corrector|
+          add_offense(range, message: format(MSG, dot: node.loc.dot.source, method: node.method_name)) do |corrector|
             autocorrect(corrector, node)
           end
         end
@@ -59,7 +59,7 @@ module RuboCop
           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.receiver.source_range.end_pos, node.loc.selector.end_pos)
 
           corrector.replace(where_loc, 'find_by')
           corrector.replace(first_loc, '')

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

@@ -24,40 +24,39 @@ module RuboCop
         RESTRICT_ON_SEND = %i[take! find_by_id! find_by!].freeze
 
         def_node_matcher :where_take?, <<~PATTERN
-          (send
-            $(send _ :where
+          (call
+            $(call _ :where
               (hash
                 (pair (sym :id) $_))) :take!)
         PATTERN
 
         def_node_matcher :find_by?, <<~PATTERN
           {
-            (send _ :find_by_id! $_)
-            (send _ :find_by! (hash (pair (sym :id) $_)))
+            (call _ :find_by_id! $_)
+            (call _ :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)
+            register_offense(range, id_value)
           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)
+            register_offense(range, id_value)
           end
         end
+        alias on_csend on_send
 
         private
 
-        def register_offense(range, id_value, bad_method)
+        def register_offense(range, id_value)
           good_method = build_good_method(id_value)
-          message = format(MSG, good_method: good_method, bad_method: bad_method)
+          message = format(MSG, good_method: good_method, bad_method: range.source)
 
           add_offense(range, message: message) do |corrector|
             corrector.replace(range, good_method)
@@ -75,19 +74,6 @@ module RuboCop
         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

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

@@ -34,7 +34,7 @@ module RuboCop
         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
 

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

@@ -69,7 +69,7 @@ module RuboCop
           return false unless CONVERT_METHODS.include?(method_name)
 
           child_node, child_method_name, time_argument = *node.children
-          return if time_argument
+          return false if time_argument
 
           current_time?(child_node, child_method_name)
         end

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

@@ -60,7 +60,7 @@ module RuboCop
           (block
             (send nil? :with_options
               (hash $...))
-            (args) ...)
+            (args _?) ...)
         PATTERN
 
         def_node_matcher :association_extension_block?, <<~PATTERN

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

@@ -6,7 +6,7 @@ module RuboCop
       # Checks for use of the helper methods which reference
       # instance variables.
       #
-      # Relying on instance variables makes it difficult to re-use helper
+      # Relying on instance variables makes it difficult to reuse helper
       # methods.
       #
       # If it seems awkward to explicitly pass in each dependent

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

@@ -40,6 +40,10 @@ module RuboCop
           (hash (kwsplat _))
         PATTERN
 
+        def_node_matcher :forwarded_kwrestarg?, <<~PATTERN
+          (hash (forwarded-kwrestarg))
+        PATTERN
+
         def_node_matcher :include_rack_test_methods?, <<~PATTERN
           (send nil? :include
             (const
@@ -83,7 +87,9 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def needs_conversion?(data)
+          return false if data.forwarded_args_type? || forwarded_kwrestarg?(data)
           return true unless data.hash_type?
           return false if kwsplat_hash?(data)
 
@@ -91,6 +97,7 @@ module RuboCop
             special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def special_keyword_arg?(node)
           node.sym_type? && KEYWORD_ARGS.include?(node.value)

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

@@ -8,10 +8,13 @@ module RuboCop
       # @example EnforcedStyle: symbolic (default)
       #   # bad
       #   render :foo, status: 200
+      #   render :foo, status: '200'
       #   render json: { foo: 'bar' }, status: 200
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
       #   head 200
+      #   assert_response 200
+      #   assert_redirected_to '/some/path', status: 301
       #
       #   # good
       #   render :foo, status: :ok
@@ -19,6 +22,8 @@ module RuboCop
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
       #   head :ok
+      #   assert_response :ok
+      #   assert_redirected_to '/some/path', status: :moved_permanently
       #
       # @example EnforcedStyle: numeric
       #   # bad
@@ -27,6 +32,8 @@ module RuboCop
       #   render plain: 'foo/bar', status: :not_modified
       #   redirect_to root_url, status: :moved_permanently
       #   head :ok
+      #   assert_response :ok
+      #   assert_redirected_to '/some/path', status: :moved_permanently
       #
       #   # good
       #   render :foo, status: 200
@@ -34,23 +41,27 @@ module RuboCop
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
       #   head 200
+      #   assert_response 200
+      #   assert_redirected_to '/some/path', status: 301
       #
       class HttpStatus < Base
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        RESTRICT_ON_SEND = %i[render redirect_to head].freeze
+        RESTRICT_ON_SEND = %i[render redirect_to head assert_response assert_redirected_to].freeze
 
         def_node_matcher :http_status, <<~PATTERN
           {
             (send nil? {:render :redirect_to} _ $hash)
             (send nil? {:render :redirect_to} $hash)
-            (send nil? :head ${int sym} ...)
+            (send nil? {:head :assert_response} ${int sym} ...)
+            (send nil? :assert_redirected_to _ $hash ...)
+            (send nil? :assert_redirected_to $hash ...)
           }
         PATTERN
 
         def_node_matcher :status_code, <<~PATTERN
-          (hash <(pair (sym :status) ${int sym}) ...>)
+          (hash <(pair (sym :status) ${int sym str}) ...>)
         PATTERN
 
         def on_send(node)
@@ -108,7 +119,7 @@ module RuboCop
           private
 
           def symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number.to_i)
           end
 
           def number
@@ -133,7 +144,7 @@ module RuboCop
           end
 
           def offensive?
-            !node.int_type? && !permitted_symbol?
+            !node.int_type? && !permitted_symbol? && number
           end
 
           def message

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

@@ -5,7 +5,13 @@ module RuboCop
     module Rails
       # Checks for places where I18n "lazy" lookup can be used.
       #
-      # @example
+      # This cop has two different enforcement modes. When the EnforcedStyle
+      # is `lazy` (the default), explicit lookups are added as offenses.
+      #
+      # When the EnforcedStyle is `explicit` then lazy lookups are added as
+      # offenses.
+      #
+      # @example EnforcedStyle: lazy (default)
       #   # en.yml
       #   # en:
       #   #   books:
@@ -28,11 +34,29 @@ module RuboCop
       #     end
       #   end
       #
+      # @example EnforcedStyle: explicit
+      #   # bad
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('.success')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('books.create.success')
+      #     end
+      #   end
+      #
       class I18nLazyLookup < Base
+        include ConfigurableEnforcedStyle
         include VisibilityHelp
         extend AutoCorrector
 
-        MSG = 'Use "lazy" lookup for the text used in controllers.'
+        MSG = 'Use %<style>s lookup for the text used in controllers.'
 
         RESTRICT_ON_SEND = %i[translate t].freeze
 
@@ -42,23 +66,45 @@ module RuboCop
 
         def on_send(node)
           translate_call?(node) do |key_node|
-            key = key_node.value
-            return if key.to_s.start_with?('.')
+            case style
+            when :lazy
+              handle_lazy_style(node, key_node)
+            when :explicit
+              handle_explicit_style(node, key_node)
+            end
+          end
+        end
+
+        private
 
-            controller, action = controller_and_action(node)
-            return unless controller && action
+        def handle_lazy_style(node, key_node)
+          key = key_node.value
+          return if key.to_s.start_with?('.')
 
-            scoped_key = get_scoped_key(key_node, controller, action)
-            return unless key == scoped_key
+          controller, action = controller_and_action(node)
+          return unless controller && action
 
-            add_offense(key_node) do |corrector|
-              unscoped_key = key_node.value.to_s.split('.').last
-              corrector.replace(key_node, "'.#{unscoped_key}'")
-            end
+          scoped_key = get_scoped_key(key_node, controller, action)
+          return unless key == scoped_key
+
+          add_offense(key_node) do |corrector|
+            unscoped_key = key_node.value.to_s.split('.').last
+            corrector.replace(key_node, "'.#{unscoped_key}'")
           end
         end
 
-        private
+        def handle_explicit_style(node, key_node)
+          key = key_node.value
+          return unless key.to_s.start_with?('.')
+
+          controller, action = controller_and_action(node)
+          return unless controller && action
+
+          scoped_key = get_scoped_key(key_node, controller, action)
+          add_offense(key_node) do |corrector|
+            corrector.replace(key_node, "'#{scoped_key}'")
+          end
+        end
 
         def controller_and_action(node)
           action_node = node.each_ancestor(:def).first
@@ -90,6 +136,10 @@ module RuboCop
 
           path.delete_suffix('Controller').underscore
         end
+
+        def message(_range)
+          format(MSG, style: style)
+        end
       end
     end
   end

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

@@ -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