rubocop-rails 2.0.1 → 2.19.1

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

@@ -3,9 +3,13 @@
 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
+      #   This cop is unsafe because it cannot be determined whether
+      #   constant or method return value specified to `class_name` is a string.
+      #
       # @example
       #   # bad
       #   has_many :accounts, class_name: Account
@@ -13,23 +17,68 @@ module RuboCop
       #
       #   # good
       #   has_many :accounts, class_name: 'Account'
-      class ReflectionClassName < Cop
+      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
 
-        def_node_matcher :association_with_reflection, <<-PATTERN
-          (send nil? {:has_many :has_one :belongs_to} _
+        def_node_matcher :association_with_reflection, <<~PATTERN
+          (send nil? {:has_many :has_one :belongs_to} _ _ ?
             (hash <$#reflection_class_name ...>)
           )
         PATTERN
 
-        def_node_matcher :reflection_class_name, <<-PATTERN
-          (pair (sym :class_name) [!dstr !str !sym])
+        def_node_matcher :reflection_class_name, <<~PATTERN
+          (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(node, location: 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?
+          else
+            !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

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

@@ -6,7 +6,7 @@ module RuboCop
       #
       # Use `assert_not` methods instead of `refute` methods.
       #
-      # @example
+      # @example EnforcedStyle: assert_not (default)
       #   # bad
       #   refute false
       #   refute_empty [1, 2, 3]
@@ -17,58 +17,79 @@ module RuboCop
       #   assert_not_empty [1, 2, 3]
       #   assert_not_equal true, false
       #
-      class RefuteMethods < Cop
-        MSG = 'Prefer `%<assert_method>s` over `%<refute_method>s`.'
+      # @example EnforcedStyle: refute
+      #   # bad
+      #   assert_not false
+      #   assert_not_empty [1, 2, 3]
+      #   assert_not_equal true, false
+      #
+      #   # good
+      #   refute false
+      #   refute_empty [1, 2, 3]
+      #   refute_equal true, false
+      #
+      class RefuteMethods < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<good_method>s` over `%<bad_method>s`.'
 
         CORRECTIONS = {
-          refute:             'assert_not',
-          refute_empty:       'assert_not_empty',
-          refute_equal:       'assert_not_equal',
-          refute_in_delta:    'assert_not_in_delta',
-          refute_in_epsilon:  'assert_not_in_epsilon',
-          refute_includes:    'assert_not_includes',
-          refute_instance_of: 'assert_not_instance_of',
-          refute_kind_of:     'assert_not_kind_of',
-          refute_nil:         'assert_not_nil',
-          refute_operator:    'assert_not_operator',
-          refute_predicate:   'assert_not_predicate',
-          refute_respond_to:  'assert_not_respond_to',
-          refute_same:        'assert_not_same',
-          refute_match:       'assert_no_match'
+          refute:             :assert_not,
+          refute_empty:       :assert_not_empty,
+          refute_equal:       :assert_not_equal,
+          refute_in_delta:    :assert_not_in_delta,
+          refute_in_epsilon:  :assert_not_in_epsilon,
+          refute_includes:    :assert_not_includes,
+          refute_instance_of: :assert_not_instance_of,
+          refute_kind_of:     :assert_not_kind_of,
+          refute_nil:         :assert_not_nil,
+          refute_operator:    :assert_not_operator,
+          refute_predicate:   :assert_not_predicate,
+          refute_respond_to:  :assert_not_respond_to,
+          refute_same:        :assert_not_same,
+          refute_match:       :assert_no_match
         }.freeze
 
-        OFFENSIVE_METHODS = CORRECTIONS.keys.freeze
+        REFUTE_METHODS = CORRECTIONS.keys.freeze
+        ASSERT_NOT_METHODS = CORRECTIONS.values.freeze
 
-        def_node_matcher :offensive?, '(send nil? #refute_method? ...)'
+        RESTRICT_ON_SEND = REFUTE_METHODS + ASSERT_NOT_METHODS
+
+        def_node_matcher :offensive?, '(send nil? #bad_method? ...)'
 
         def on_send(node)
           return unless offensive?(node)
 
-          message = offense_message(node.method_name)
-          add_offense(node, location: :selector, message: message)
-        end
+          method_name = node.method_name
+          message = offense_message(method_name)
+          range = node.loc.selector
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node.loc.selector,
-              CORRECTIONS[node.method_name]
-            )
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, convert_good_method(method_name))
           end
         end
 
         private
 
-        def refute_method?(method_name)
-          OFFENSIVE_METHODS.include?(method_name)
+        def bad_method?(method_name)
+          if style == :assert_not
+            REFUTE_METHODS.include?(method_name)
+          else
+            ASSERT_NOT_METHODS.include?(method_name)
+          end
         end
 
         def offense_message(method_name)
-          format(
-            MSG,
-            refute_method: method_name,
-            assert_method: CORRECTIONS[method_name]
-          )
+          format(MSG, bad_method: method_name, good_method: convert_good_method(method_name))
+        end
+
+        def convert_good_method(bad_method)
+          if style == :assert_not
+            CORRECTIONS.fetch(bad_method)
+          else
+            CORRECTIONS.invert.fetch(bad_method)
+          end
         end
       end
     end

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

@@ -3,9 +3,12 @@
 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
+      #   This cop's autocorrection is unsafe because its dependence on the constant is not corrected.
+      #
       # @example
       #   # bad
       #   class SomeClass
@@ -14,19 +17,31 @@ module RuboCop
       #
       #   # good
       #   class SomeClass
+      #     EXPIRES = 1.week
+      #
+      #     def self.expired_at
+      #       EXPIRES.since
+      #     end
+      #   end
+      #
+      #   # good
+      #   class SomeClass
       #     def self.expired_at
       #       1.week.since
       #     end
       #   end
-      class RelativeDateConstant < Cop
+      class RelativeDateConstant < Base
         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)
-          relative_date_assignment?(node) do |method_name|
-            add_offense(node, message: format(MSG, method_name: method_name))
+          nested_relative_date(node) do |method_name|
+            add_offense(node, message: message(method_name)) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
         end
 
@@ -38,54 +53,58 @@ module RuboCop
           lhs.children.zip(rhs.children).each do |(name, value)|
             next unless name.casgn_type?
 
-            relative_date?(value) do |method_name|
-              add_offense(node,
-                          location: range_between(name.loc.expression.begin_pos,
-                                                  value.loc.expression.end_pos),
-                          message: format(MSG, method_name: method_name))
+            nested_relative_date(value) do |method_name|
+              add_offense(offense_range(name, value), message: message(method_name)) do |corrector|
+                autocorrect(corrector, node)
+              end
             end
           end
         end
 
         def on_or_asgn(node)
-          relative_date_or_assignment?(node) do |method_name|
+          relative_date_or_assignment(node) do |method_name|
             add_offense(node, message: format(MSG, method_name: method_name))
           end
         end
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           return unless node.casgn_type?
 
           scope, const_name, value = *node
           return unless scope.nil?
 
           indent = ' ' * node.loc.column
-          new_code = ["def self.#{const_name.downcase}",
-                      "#{indent}#{value.source}",
-                      'end'].join("\n#{indent}")
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+          new_code = ["def self.#{const_name.downcase}", "#{indent}#{value.source}", 'end'].join("\n#{indent}")
+
+          corrector.replace(node, new_code)
         end
 
-        private
+        def message(method_name)
+          format(MSG, method_name: method_name)
+        end
 
-        def_node_matcher :relative_date_assignment?, <<-PATTERN
-          {
-            (casgn _ _ (send _ ${:since :from_now :after :ago :until :before}))
-            (casgn _ _ ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before})))
-            (casgn _ _ ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _))
-          }
-        PATTERN
+        def offense_range(name, value)
+          range_between(name.source_range.begin_pos, value.source_range.end_pos)
+        end
+
+        def nested_relative_date(node, &callback)
+          return if node.nil? || node.block_type?
+
+          node.each_child_node do |child|
+            nested_relative_date(child, &callback)
+          end
+
+          relative_date(node, &callback)
+        end
 
-        def_node_matcher :relative_date_or_assignment?, <<-PATTERN
-          (:or_asgn (casgn _ _) (send _ ${:since :from_now :after :ago :until :before}))
+        def_node_matcher :relative_date_or_assignment, <<~PATTERN
+          (:or_asgn (casgn _ _) (send _ $RELATIVE_DATE_METHODS))
         PATTERN
 
-        def_node_matcher :relative_date?, <<-PATTERN
-          {
-            ({erange irange} _ (send _ ${:since :from_now :after :ago :until :before}))
-            ({erange irange} (send _ ${:since :from_now :after :ago :until :before}) _)
-            (send _ ${:since :from_now :after :ago :until :before})
-          }
+        def_node_matcher :relative_date, <<~PATTERN
+          (send _ $RELATIVE_DATE_METHODS)
         PATTERN
       end
     end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Looks for inline rendering within controller actions.
+      #
+      # @example
+      #   # bad
+      #   class ProductsController < ApplicationController
+      #     def index
+      #       render inline: "<% products.each do |p| %><p><%= p.name %></p><% end %>", type: :erb
+      #     end
+      #   end
+      #
+      #   # good
+      #   # app/views/products/index.html.erb
+      #   # <% products.each do |p| %>
+      #   #   <p><%= p.name %></p>
+      #   # <% end %>
+      #
+      #   class ProductsController < ApplicationController
+      #     def index
+      #     end
+      #   end
+      #
+      class RenderInline < Base
+        MSG = 'Prefer using a template over inline rendering.'
+        RESTRICT_ON_SEND = %i[render].freeze
+
+        def_node_matcher :render_with_inline_option?, <<~PATTERN
+          (send nil? :render (hash <(pair {(sym :inline) (str "inline")} _) ...>))
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if render_with_inline_option?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies places where `render text:` can be
+      # replaced with `render plain:`.
+      #
+      # @example
+      #   # bad - explicit MIME type to `text/plain`
+      #   render text: 'Ruby!', content_type: 'text/plain'
+      #
+      #   # good - short and precise
+      #   render plain: 'Ruby!'
+      #
+      #   # good - explicit MIME type not to `text/plain`
+      #   render text: 'Ruby!', content_type: 'text/html'
+      #
+      # @example ContentTypeCompatibility: true (default)
+      #   # good - sets MIME type to `text/html`
+      #   render text: 'Ruby!'
+      #
+      # @example ContentTypeCompatibility: false
+      #   # bad - sets MIME type to `text/html`
+      #   render text: 'Ruby!'
+      #
+      class RenderPlainText < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `render plain:` over `render text:`.'
+        RESTRICT_ON_SEND = %i[render].freeze
+
+        def_node_matcher :render_plain_text?, <<~PATTERN
+          (send nil? :render $(hash <$(pair (sym :text) $_) ...>))
+        PATTERN
+
+        def on_send(node)
+          render_plain_text?(node) do |options_node, option_node, option_value|
+            content_type_node = find_content_type(options_node)
+            return unless compatible_content_type?(content_type_node)
+
+            add_offense(node) do |corrector|
+              rest_options = options_node.pairs - [option_node, content_type_node].compact
+
+              corrector.replace(node, replacement(rest_options, option_value))
+            end
+          end
+        end
+
+        private
+
+        def find_content_type(node)
+          node.pairs.find { |p| p.key.value.to_sym == :content_type }
+        end
+
+        def compatible_content_type?(node)
+          (node && node.value.value == 'text/plain') ||
+            (!node && !cop_config['ContentTypeCompatibility'])
+        end
+
+        def replacement(rest_options, option_value)
+          if rest_options.any?
+            "render plain: #{option_value.source}, #{rest_options.map(&:source).join(', ')}"
+          else
+            "render plain: #{option_value.source}"
+          end
+        end
+      end
+    end
+  end
+end

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)
@@ -19,13 +19,14 @@ module RuboCop
       #
       #   # good
       #   request.referrer
-      class RequestReferer < Cop
+      class RequestReferer < Base
         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
+        def_node_matcher :referer?, <<~PATTERN
           (send (send nil? :request) {:referer :referrer})
         PATTERN
 
@@ -33,17 +34,15 @@ module RuboCop
           referer?(node) do
             return unless node.method?(wrong_method_name)
 
-            add_offense(node.source_range, location: node.source_range)
+            add_offense(node.source_range) do |corrector|
+              corrector.replace(node, "request.#{style}")
+            end
           end
         end
 
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node, "request.#{style}") }
-        end
-
         private
 
-        def message(_node)
+        def message(_range)
           format(MSG, prefer: style, current: wrong_method_name)
         end
 

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # 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,
+      # just refer to classes and modules normally.
+      # If the constant name is dynamic, camelize if needed, and constantize.
+      #
+      # Applications running in Zeitwerk mode should not use `require_dependency`.
+      #
+      # NOTE: This cop is disabled by default. Please enable it if you are using Zeitwerk mode.
+      #
+      # @example
+      #   # bad
+      #   require_dependency 'some_lib'
+      class RequireDependency < Base
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 6.0
+
+        MSG = 'Do not use `require_dependency` with Zeitwerk mode.'
+        RESTRICT_ON_SEND = %i[require_dependency].freeze
+
+        def_node_matcher :require_dependency_call?, <<~PATTERN
+          (send {nil? (const {nil? cbase} :Kernel)} :require_dependency _)
+        PATTERN
+
+        def on_send(node)
+          require_dependency_call?(node) { add_offense(node) }
+        end
+      end
+    end
+  end
+end

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