rubocop-rails 2.14.2 → 2.19.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks if the value of the option `class_name`, in
+      # Checks if the value of the option `class_name`, in
       # the definition of a reflection is a string.
       #
       # @safety
@@ -18,6 +18,8 @@ module RuboCop
       #   # good
       #   has_many :accounts, class_name: 'Account'
       class ReflectionClassName < Base
+        extend AutoCorrector
+
         MSG = 'Use a string value for `class_name`.'
         RESTRICT_ON_SEND = %i[has_many has_one belongs_to].freeze
         ALLOWED_REFLECTION_CLASS_TYPES = %i[dstr str sym].freeze
@@ -32,14 +34,37 @@ module RuboCop
           (pair (sym :class_name) #reflection_class_value?)
         PATTERN
 
+        def_node_matcher :const_or_string, <<~PATTERN
+          {$(const nil? _) (send $(const nil? _) :name) (send $(const nil? _) :to_s)}
+        PATTERN
+
         def on_send(node)
           association_with_reflection(node) do |reflection_class_name|
-            add_offense(reflection_class_name.loc.expression)
+            return if reflection_class_name.value.send_type? && reflection_class_name.value.receiver.nil?
+            return if reflection_class_name.value.lvar_type? && str_assigned?(reflection_class_name)
+
+            add_offense(reflection_class_name.source_range) do |corrector|
+              autocorrect(corrector, reflection_class_name)
+            end
           end
         end
 
         private
 
+        def str_assigned?(reflection_class_name)
+          lvar = reflection_class_name.value.source
+
+          reflection_class_name.ancestors.each do |nodes|
+            return true if nodes.each_child_node(:lvasgn).detect do |node|
+              lhs, rhs = *node
+
+              lhs.to_s == lvar && ALLOWED_REFLECTION_CLASS_TYPES.include?(rhs.type)
+            end
+          end
+
+          false
+        end
+
         def reflection_class_value?(class_value)
           if class_value.send_type?
             !class_value.method?(:to_s) || class_value.receiver&.const_type?
@@ -47,6 +72,14 @@ module RuboCop
             !ALLOWED_REFLECTION_CLASS_TYPES.include?(class_value.type)
           end
         end
+
+        def autocorrect(corrector, class_config)
+          class_value = class_config.value
+          replacement = const_or_string(class_value)
+          return unless replacement.present?
+
+          corrector.replace(class_value, replacement.source.inspect)
+        end
       end
     end
   end

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

@@ -81,11 +81,7 @@ module RuboCop
         end
 
         def offense_message(method_name)
-          format(
-            MSG,
-            bad_method: method_name,
-            good_method: convert_good_method(method_name)
-          )
+          format(MSG, bad_method: method_name, good_method: convert_good_method(method_name))
         end
 
         def convert_good_method(bad_method)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks whether constant value isn't relative date.
+      # Checks whether constant value isn't relative date.
       # Because the relative date will be evaluated only once.
       #
       # @safety
@@ -34,8 +34,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not assign `%<method_name>s` to constants as it ' \
-              'will be evaluated only once.'
+        MSG = 'Do not assign `%<method_name>s` to constants as it will be evaluated only once.'
         RELATIVE_DATE_METHODS = %i[since from_now after ago until before yesterday tomorrow].to_set.freeze
 
         def on_casgn(node)
@@ -77,11 +76,9 @@ module RuboCop
           return unless scope.nil?
 
           indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
+          new_code = ["def self.#{const_name.downcase}", "#{indent}#{value.source}", 'end'].join("\n#{indent}")
 
-          corrector.replace(node.source_range, new_code)
+          corrector.replace(node, new_code)
         end
 
         def message(method_name)
@@ -89,7 +86,7 @@ module RuboCop
         end
 
         def offense_range(name, value)
-          range_between(name.loc.expression.begin_pos, value.loc.expression.end_pos)
+          range_between(name.source_range.begin_pos, value.source_range.end_pos)
         end
 
         def nested_relative_date(node, &callback)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for inline rendering within controller actions.
+      # Looks for inline rendering within controller actions.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop identifies places where `render text:` can be
+      # Identifies places where `render text:` can be
       # replaced with `render plain:`.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for consistent uses of `request.referer` or
+      # Checks for consistent uses of `request.referer` or
       # `request.referrer`, depending on the cop's configuration.
       #
       # @example EnforcedStyle: referer (default)
@@ -23,8 +23,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
         extend AutoCorrector
 
-        MSG = 'Use `request.%<prefer>s` instead of ' \
-              '`request.%<current>s`.'
+        MSG = 'Use `request.%<prefer>s` instead of `request.%<current>s`.'
         RESTRICT_ON_SEND = %i[referer referrer].freeze
 
         def_node_matcher :referer?, <<~PATTERN

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the usage of `require_dependency`.
+      # Checks for the usage of `require_dependency`.
       #
       # `require_dependency` is an obsolete method for Rails applications running in Zeitwerk mode.
       # In Zeitwerk mode, the semantics should match Ruby's and no need to be defensive with load order,
@@ -26,7 +26,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[require_dependency].freeze
 
         def_node_matcher :require_dependency_call?, <<~PATTERN
-          (send {nil? (const _ :Kernel)} :require_dependency _)
+          (send {nil? (const {nil? cbase} :Kernel)} :require_dependency _)
         PATTERN
 
         def on_send(node)

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Prefer `response.parsed_body` to `JSON.parse(response.body)`.
+      #
+      # @safety
+      #   This cop is unsafe because Content-Type may not be `application/json`. For example, the proprietary
+      #   Content-Type provided by corporate entities such as `application/vnd.github+json` is not supported at
+      #   `response.parsed_body` by default, so you still have to use `JSON.parse(response.body)` there.
+      #
+      # @example
+      #   # bad
+      #   JSON.parse(response.body)
+      #
+      #   # good
+      #   response.parsed_body
+      class ResponseParsedBody < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Prefer `response.parsed_body` to `JSON.parse(response.body)`.'
+
+        RESTRICT_ON_SEND = %i[parse].freeze
+
+        minimum_target_rails_version 5.0
+
+        # @!method json_parse_response_body?(node)
+        def_node_matcher :json_parse_response_body?, <<~PATTERN
+          (send
+            (const {nil? cbase} :JSON)
+            :parse
+            (send
+              (send nil? :response)
+              :body
+            )
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless json_parse_response_body?(node)
+
+          add_offense(node) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          corrector.replace(node, 'response.parsed_body')
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks whether the change method of the migration file is
+      # Checks whether the change method of the migration file is
       # reversible.
       #
       # @example
@@ -16,23 +16,15 @@ module RuboCop
       #
       #   # good
       #   def change
-      #     create_table :users do |t|
-      #       t.string :name
+      #     change_table :users do |t|
+      #       t.remove :name, :string
       #     end
       #   end
       #
       #   # good
       #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.column :name, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.remove :name
-      #         end
-      #       end
+      #     create_table :users do |t|
+      #       t.string :name
       #     end
       #   end
       #
@@ -114,21 +106,6 @@ module RuboCop
       #     end
       #   end
       #
-      #   # good
-      #   def change
-      #     reversible do |dir|
-      #       change_table :users do |t|
-      #         dir.up do
-      #           t.change :price, :string
-      #         end
-      #
-      #         dir.down do
-      #           t.change :price, :integer
-      #         end
-      #       end
-      #     end
-      #   end
-      #
       # @example
       #   # remove_columns
       #
@@ -173,8 +150,6 @@ module RuboCop
       #   def change
       #     remove_index :users, column: :email
       #   end
-      #
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Migration/CommandRecorder.html
       class ReversibleMigration < Base
         include MigrationsHelper
 
@@ -229,6 +204,8 @@ module RuboCop
           check_change_table_node(node.send_node, node.body)
         end
 
+        alias on_numblock on_block
+
         private
 
         def check_irreversible_schema_statement_node(node)
@@ -240,10 +217,7 @@ module RuboCop
         def check_drop_table_node(node)
           drop_table_call(node) do
             unless node.parent.block_type? || node.last_argument.block_pass_type?
-              add_offense(
-                node,
-                message: format(MSG, action: 'drop_table(without block)')
-              )
+              add_offense(node, message: format(MSG, action: 'drop_table(without block)'))
             end
           end
         end
@@ -251,22 +225,12 @@ module RuboCop
         def check_reversible_hash_node(node)
           return if reversible_change_table_call?(node)
 
-          add_offense(
-            node,
-            message: format(
-              MSG, action: "#{node.method_name}(without :from and :to)"
-            )
-          )
+          add_offense(node, message: format(MSG, action: "#{node.method_name}(without :from and :to)"))
         end
 
         def check_remove_column_node(node)
           remove_column_call(node) do |args|
-            if args.to_a.size < 3
-              add_offense(
-                node,
-                message: format(MSG, action: 'remove_column(without type)')
-              )
-            end
+            add_offense(node, message: format(MSG, action: 'remove_column(without type)')) if args.to_a.size < 3
           end
         end
 
@@ -295,10 +259,7 @@ module RuboCop
             unless all_hash_key?(args, :type) && target_rails_version >= 6.1
               action = target_rails_version >= 6.1 ? 'remove_columns(without type)' : 'remove_columns'
 
-              add_offense(
-                node,
-                message: format(MSG, action: action)
-              )
+              add_offense(node, message: format(MSG, action: action))
             end
           end
         end
@@ -306,18 +267,14 @@ module RuboCop
         def check_remove_index_node(node)
           remove_index_call(node) do |args|
             if args.hash_type? && !all_hash_key?(args, :column)
-              add_offense(
-                node,
-                message: format(MSG, action: 'remove_index(without column)')
-              )
+              add_offense(node, message: format(MSG, action: 'remove_index(without column)'))
             end
           end
         end
 
         def check_change_table_offense(receiver, node)
           method_name = node.method_name
-          return if receiver != node.receiver &&
-                    reversible_change_table_call?(node)
+          return if receiver != node.receiver && reversible_change_table_call?(node)
 
           action = if method_name == :remove
                      target_rails_version >= 6.1 ? 't.remove (without type)' : 't.remove'
@@ -325,10 +282,7 @@ module RuboCop
                      "change_table(with #{method_name})"
                    end
 
-          add_offense(
-            node,
-            message: format(MSG, action: action)
-          )
+          add_offense(node, message: format(MSG, action: action))
         end
 
         def reversible_change_table_call?(node)
@@ -353,9 +307,7 @@ module RuboCop
 
         def within_reversible_or_up_only_block?(node)
           node.each_ancestor(:block).any? do |ancestor|
-            (ancestor.block_type? &&
-              ancestor.send_node.method?(:reversible)) ||
-              ancestor.send_node.method?(:up_only)
+            (ancestor.block_type? && ancestor.send_node.method?(:reversible)) || ancestor.send_node.method?(:up_only)
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks whether the migration implements
+      # Checks whether the migration implements
       # either a `change` method or both an `up` and a `down`
       # method.
       #
@@ -45,19 +45,18 @@ module RuboCop
       class ReversibleMigrationMethodDefinition < Base
         include MigrationsHelper
 
-        MSG = 'Migrations must contain either a `change` method, or ' \
-              'both an `up` and a `down` method.'
+        MSG = 'Migrations must contain either a `change` method, or both an `up` and a `down` method.'
 
         def_node_matcher :change_method?, <<~PATTERN
-          [ #migration_class? `(def :change (args) _) ]
+          `(def :change (args) _)
         PATTERN
 
         def_node_matcher :up_and_down_methods?, <<~PATTERN
-          [ #migration_class? `(def :up (args) _) `(def :down (args) _) ]
+          [`(def :up (args) _) `(def :down (args) _)]
         PATTERN
 
         def on_class(node)
-          return if change_method?(node) || up_and_down_methods?(node)
+          return if !migration_class?(node) || change_method?(node) || up_and_down_methods?(node)
 
           add_offense(node)
         end

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

@@ -39,7 +39,7 @@ module RuboCop
         def on_send(node)
           evidence(node) do |rails_node, args|
             add_offense(node, message: format(MSG, root: rails_node.source)) do |corrector|
-              range = range_between(rails_node.loc.selector.end_pos, node.loc.expression.end_pos)
+              range = range_between(rails_node.loc.selector.end_pos, node.source_range.end_pos)
               replacement = ".join(#{args.map(&:source).join(', ')})"
 
               corrector.replace(range, replacement)

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

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Use `Rails.root` IO methods instead of passing it to `File`.
+      #
+      # `Rails.root` is an instance of `Pathname`
+      # so we can apply many IO methods directly.
+      #
+      # This cop works best when used together with
+      # `Style/FileRead`, `Style/FileWrite` and `Rails/RootJoinChain`.
+      #
+      # @safety
+      #   This cop is unsafe for autocorrection because `Dir`'s `children`, `each_child`, `entries`, and `glob`
+      #   methods return string element, but these methods of `Pathname` return `Pathname` element.
+      #
+      # @example
+      #   # bad
+      #   File.open(Rails.root.join('db', 'schema.rb'))
+      #   File.open(Rails.root.join('db', 'schema.rb'), 'w')
+      #   File.read(Rails.root.join('db', 'schema.rb'))
+      #   File.binread(Rails.root.join('db', 'schema.rb'))
+      #   File.write(Rails.root.join('db', 'schema.rb'), content)
+      #   File.binwrite(Rails.root.join('db', 'schema.rb'), content)
+      #
+      #   # good
+      #   Rails.root.join('db', 'schema.rb').open
+      #   Rails.root.join('db', 'schema.rb').open('w')
+      #   Rails.root.join('db', 'schema.rb').read
+      #   Rails.root.join('db', 'schema.rb').binread
+      #   Rails.root.join('db', 'schema.rb').write(content)
+      #   Rails.root.join('db', 'schema.rb').binwrite(content)
+      #
+      class RootPathnameMethods < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = '`%<rails_root>s` is a `Pathname` so you can just append `#%<method>s`.'
+
+        DIR_METHODS = %i[children delete each_child empty? entries exist? glob mkdir open rmdir unlink].to_set.freeze
+
+        FILE_METHODS = %i[
+          atime
+          basename
+          binread
+          binwrite
+          birthtime
+          blockdev?
+          chardev?
+          chmod
+          chown
+          ctime
+          delete
+          directory?
+          dirname
+          empty?
+          executable?
+          executable_real?
+          exist?
+          expand_path
+          extname
+          file?
+          fnmatch
+          fnmatch?
+          ftype
+          grpowned?
+          join
+          lchmod
+          lchown
+          lstat
+          mtime
+          open
+          owned?
+          pipe?
+          read
+          readable?
+          readable_real?
+          readlines
+          readlink
+          realdirpath
+          realpath
+          rename
+          setgid?
+          setuid?
+          size
+          size?
+          socket?
+          split
+          stat
+          sticky?
+          symlink?
+          sysopen
+          truncate
+          unlink
+          utime
+          world_readable?
+          world_writable?
+          writable?
+          writable_real?
+          write
+          zero?
+        ].to_set.freeze
+
+        FILE_TEST_METHODS = %i[
+          blockdev?
+          chardev?
+          directory?
+          empty?
+          executable?
+          executable_real?
+          exist?
+          file?
+          grpowned?
+          owned?
+          pipe?
+          readable?
+          readable_real?
+          setgid?
+          setuid?
+          size
+          size?
+          socket?
+          sticky?
+          symlink?
+          world_readable?
+          world_writable?
+          writable?
+          writable_real?
+          zero?
+        ].to_set.freeze
+
+        FILE_UTILS_METHODS = %i[chmod chown mkdir mkpath rmdir rmtree].to_set.freeze
+
+        RESTRICT_ON_SEND = (DIR_METHODS + FILE_METHODS + FILE_TEST_METHODS + FILE_UTILS_METHODS).to_set.freeze
+
+        def_node_matcher :pathname_method, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Dir) $DIR_METHODS $_ $...)
+            (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
+            (send (const {nil? cbase} :FileTest) $FILE_TEST_METHODS $_ $...)
+            (send (const {nil? cbase} :FileUtils) $FILE_UTILS_METHODS $_ $...)
+          }
+        PATTERN
+
+        def_node_matcher :dir_glob?, <<~PATTERN
+          (send
+            (const {cbase nil?} :Dir) :glob ...)
+        PATTERN
+
+        def_node_matcher :rails_root_pathname?, <<~PATTERN
+          {
+            $#rails_root?
+            (send $#rails_root? :join ...)
+          }
+        PATTERN
+
+        # @!method rails_root?(node)
+        def_node_matcher :rails_root?, <<~PATTERN
+          (send (const {nil? cbase} :Rails) {:root :public_path})
+        PATTERN
+
+        def on_send(node)
+          evidence(node) do |method, path, args, rails_root|
+            add_offense(node, message: format(MSG, method: method, rails_root: rails_root.source)) do |corrector|
+              replacement = if dir_glob?(node)
+                              build_path_glob_replacement(path, method)
+                            else
+                              build_path_replacement(path, method, args)
+                            end
+
+              corrector.replace(node, replacement)
+            end
+          end
+        end
+
+        private
+
+        def evidence(node)
+          return if node.method?(:open) && node.parent&.send_type?
+          return unless (method, path, args = pathname_method(node)) && (rails_root = rails_root_pathname?(path))
+
+          yield(method, path, args, rails_root)
+        end
+
+        def build_path_glob_replacement(path, method)
+          receiver = range_between(path.source_range.begin_pos, path.children.first.loc.selector.end_pos).source
+
+          argument = path.arguments.one? ? path.first_argument.source : join_arguments(path.arguments)
+
+          "#{receiver}.#{method}(#{argument})"
+        end
+
+        def build_path_replacement(path, method, args)
+          path_replacement = path.source
+          if path.arguments? && !path.parenthesized_call?
+            path_replacement[' '] = '('
+            path_replacement << ')'
+          end
+
+          replacement = "#{path_replacement}.#{method}"
+          replacement += "(#{args.map(&:source).join(', ')})" unless args.empty?
+          replacement
+        end
+
+        def include_interpolation?(arguments)
+          arguments.any? do |argument|
+            argument.children.any? { |child| child.respond_to?(:begin_type?) && child.begin_type? }
+          end
+        end
+
+        def join_arguments(arguments)
+          use_interpolation = false
+
+          joined_arguments = arguments.map do |arg|
+            if arg.respond_to?(:value)
+              arg.value
+            else
+              use_interpolation = true
+              "\#{#{arg.source}}"
+            end
+          end.join('/')
+          quote = enforce_double_quotes? || include_interpolation?(arguments) || use_interpolation ? '"' : "'"
+
+          "#{quote}#{joined_arguments}#{quote}"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
+      end
+    end
+  end
+end