rubocop-rails 2.32.0 → 2.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '009a04a87f7692e278ce16b061ff93814ada6644691ce2fdd4ac4c7659e68c4d'
-  data.tar.gz: 313e26b30279cf9ebba24f5f99bc78b2b44433b24bc3522a6d4261de1cf72282
+  metadata.gz: ffddf417706a66433be596f397b807c824a2593bea0a5175907be9d9be318970
+  data.tar.gz: 40672bac8ab7a1961102c3f5306526fa98a360987c7095128313dd5bae7c5641
 SHA512:
-  metadata.gz: 1f7397609be46c75da8ff050ed1325db850c39df7d097d9faeb6984162b706ed92e203f151a30a68aa41b3af8fcdd63b7e76c51ebdcfe31980129a853d7cd8a3
-  data.tar.gz: 46006ebeb148838e1ae7f3dc56614b261fc90779c5e3772e163c9431034a89dbc614ef1cb1b913d5236fbc2b04708643fc27b593d8c0c4147898271c045cb4c7
+  metadata.gz: 16ba2fc1926397b8b5c413c207a9f45e80a30b53e1e73b215e18abf38218e3aea3ecd2090cc4858adfe4a9d32ebb527b83db57acb38cff48510d4eaf18dcdd9c
+  data.tar.gz: 6541216ccafd3cd5287517989ea8a49dcb4b547ca98d0c363f58ac5a11ebbe6452329ea0964357e7f9777a5224d05d271b6bd21ee31f0d0bffcb37dfaa26dbd0

data/config/default.yml

@@ -91,6 +91,12 @@ Lint/UselessAccessModifier:
     - concern
     - concerning
 
+Lint/UselessMethodDefinition:
+  # Avoids conflict with `Rails/LexicallyScopedActionFilter` cop.
+  Exclude:
+    - '**/app/controllers/**/*.rb'
+    - '**/app/mailers/**/*.rb'
+
 Rails:
   Enabled: true
   DocumentationBaseURL: https://docs.rubocop.org/rubocop-rails
@@ -402,7 +408,7 @@ Rails/DuplicateAssociation:
   VersionChanged: '2.18'
 
 Rails/DuplicateScope:
-  Description: 'Multiple scopes share this same where clause.'
+  Description: 'Multiple scopes share this same expression.'
   Enabled: pending
   Severity: warning
   VersionAdded: '2.14'
@@ -453,6 +459,7 @@ Rails/EnumSyntax:
   VersionAdded: '2.26'
   Include:
     - '**/app/models/**/*.rb'
+    - '**/lib/**/*.rb'
 
 Rails/EnumUniqueness:
   Description: 'Avoid duplicate integers in hash-syntax `enum` declaration.'
@@ -461,6 +468,11 @@ Rails/EnumUniqueness:
   Include:
     - '**/app/models/**/*.rb'
 
+Rails/Env:
+  Description: 'Use Feature Flags or config instead of `Rails.env`.'
+  Enabled: false
+  VersionAdded: '2.34'
+
 Rails/EnvLocal:
   Description: 'Use `Rails.env.local?` instead of `Rails.env.development? || Rails.env.test?`.'
   Enabled: pending
@@ -532,6 +544,13 @@ Rails/FindById:
   Enabled: 'pending'
   VersionAdded: '2.7'
 
+Rails/FindByOrAssignmentMemoization:
+  Description: 'Avoid memoizing `find_by` results with `||=`.'
+  StyleGuide: 'https://rails.rubystyle.guide/#find-by-memoization'
+  Enabled: pending
+  Safe: false
+  VersionAdded: '2.33'
+
 Rails/FindEach:
   Description: 'Prefer all.find_each over all.each.'
   StyleGuide: 'https://rails.rubystyle.guide#find-each'
@@ -595,6 +614,14 @@ Rails/HttpStatus:
     - numeric
     - symbolic
 
+Rails/HttpStatusNameConsistency:
+  Description: 'Enforces consistency by using the current HTTP status names.'
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '2.34'
+  Include:
+    - '**/app/controllers/**/*.rb'
+
 Rails/I18nLazyLookup:
   Description: 'Checks for places where I18n "lazy" lookup can be used.'
   StyleGuide: 'https://rails.rubystyle.guide/#lazy-lookup'
@@ -647,8 +674,9 @@ Rails/IndexBy:
 Rails/IndexWith:
   Description: 'Prefer `index_with` over `each_with_object`, `to_h`, or `map`.'
   Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '2.5'
-  VersionChanged: '2.8'
+  VersionChanged: '2.33'
 
 Rails/Inquiry:
   Description: "Prefer Ruby's comparison operators over Active Support's `Array#inquiry` and `String#inquiry`."
@@ -742,6 +770,13 @@ Rails/NotNullColumn:
   Include:
     - db/**/*.rb
 
+Rails/OrderArguments:
+  Description: 'Prefer symbol arguments over strings in `order` method.'
+  StyleGuide: 'https://rails.rubystyle.guide/#order-arguments'
+  Enabled: pending
+  VersionAdded: '2.33'
+  Safe: false
+
 Rails/OrderById:
   Description: >-
                   Do not use the `id` column for ordering.
@@ -809,6 +844,7 @@ Rails/Presence:
   Description: 'Checks code that can be written more easily using `Object#presence` defined by Active Support.'
   Enabled: true
   VersionAdded: '0.52'
+  VersionChanged: '2.34'
 
 Rails/Present:
   Description: 'Enforces use of `present?`.'
@@ -845,6 +881,14 @@ Rails/ReadWriteAttribute:
   Include:
     - '**/app/models/**/*.rb'
 
+Rails/RedirectBackOrTo:
+  Description: >-
+                  Use `redirect_back_or_to` instead of `redirect_back` with
+                  `fallback_location` option.
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '2.34'
+
 Rails/RedundantActiveRecordAllMethod:
   Description: Detect redundant `all` used as a receiver for Active Record query methods.
   StyleGuide: 'https://rails.rubystyle.guide/#redundant-all'
@@ -1126,7 +1170,7 @@ Rails/ThreeStateBooleanColumn:
 Rails/TimeZone:
   Description: 'Checks the correct usage of time zone aware methods.'
   StyleGuide: 'https://rails.rubystyle.guide#time'
-  Reference: 'http://danilenko.org/2012/7/6/rails_timezones'
+  Reference: 'https://danilenko.org/2012/7/6/rails_timezones'
   Enabled: true
   SafeAutoCorrect: false
   VersionAdded: '0.30'

data/lib/rubocop/cop/mixin/active_record_helper.rb

@@ -106,7 +106,7 @@ module RuboCop
         send_node = node.each_ancestor(:call).first
         return false unless send_node
 
-        return true if WHERE_METHODS.include?(send_node.method_name)
+        return true if WHERE_METHODS.include?(send_node.method_name) && send_node.receiver != node
 
         receiver = send_node.receiver
         return false unless receiver&.send_type?

data/lib/rubocop/cop/mixin/index_method.rb

@@ -132,9 +132,13 @@ module RuboCop
         add_offense(
           node, message: "Prefer `#{new_method_name}` over `#{match_desc}`."
         ) do |corrector|
+          next if part_of_ignored_node?(node)
+
           correction = prepare_correction(node)
           execute_correction(corrector, node, correction)
         end
+
+        ignore_node(node)
       end
 
       def extract_captures(match)

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

@@ -73,7 +73,7 @@ module RuboCop
             return false if use_redirect_to?(context)
 
             context = node
-          elsif context.right_siblings.empty?
+          elsif context.right_siblings.empty? && !use_redirect_to?(context.parent)
             return true
           end
           context = context.right_siblings
@@ -98,7 +98,9 @@ module RuboCop
         end
 
         def use_redirect_to?(context)
-          context.right_siblings.compact.any? do |sibling|
+          context.right_siblings.any? do |sibling|
+            next unless sibling.is_a?(AST::Node)
+
             # Unwrap `return redirect_to :index`
             sibling = sibling.children.first if sibling.return_type? && sibling.children.one?
             sibling.send_type? && sibling.method?(:redirect_to)

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

@@ -76,7 +76,7 @@ module RuboCop
 
         def on_def(node)
           return unless trivial_delegate?(node)
-          return if private_or_protected_delegation(node)
+          return if private_or_protected_delegation?(node)
           return if module_function_declared?(node)
 
           register_offense(node)
@@ -163,8 +163,8 @@ module RuboCop
           end
         end
 
-        def private_or_protected_delegation(node)
-          private_or_protected_inline(node) || node_visibility(node) != :public
+        def private_or_protected_delegation?(node)
+          private_or_protected_inline?(node) || node_visibility(node) != :public
         end
 
         def module_function_declared?(node)
@@ -173,7 +173,7 @@ module RuboCop
           end
         end
 
-        def private_or_protected_inline(node)
+        def private_or_protected_inline?(node)
           processed_source[node.first_line - 1].strip.match?(/\A(private )|(protected )/)
         end
       end

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

@@ -94,7 +94,7 @@ module RuboCop
           filtered_nodes = association_nodes.reject { |node| node.method?(:belongs_to) }
           grouped_associations = filtered_nodes.group_by do |node|
             arguments = association(node).last
-            next unless arguments.count == 1
+            next unless arguments.one?
 
             if (class_name = class_name(arguments.first))
               class_name.source

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks for multiple scopes in a model that have the same `where` clause. This
+      # Checks for multiple scopes in a model that have the same expression. This
       # often means you copy/pasted a scope, updated the name, and forgot to change the condition.
       #
       # @example
@@ -19,7 +19,7 @@ module RuboCop
       class DuplicateScope < Base
         include ClassSendNodeHelper
 
-        MSG = 'Multiple scopes share this same where clause.'
+        MSG = 'Multiple scopes share this same expression.'
 
         def_node_matcher :scope, <<~PATTERN
           (send nil? :scope _ $...)

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for usage of `Rails.env` which can be replaced with Feature Flags
+      #
+      # @example
+      #
+      #   # bad
+      #   Rails.env.production? || Rails.env.local?
+      #
+      #   # good
+      #   if FeatureFlag.enabled?(:new_feature)
+      #     # new feature code
+      #   end
+      #
+      class Env < Base
+        MSG = 'Use Feature Flags or config instead of `Rails.env`.'
+        RESTRICT_ON_SEND = %i[env].freeze
+        # This allow list is derived from:
+        # (Rails.env.methods - Object.instance_methods).select { |m| m.to_s.end_with?('?') }
+        # and then removing the environment specific methods like development?, test?, production?, local?
+        ALLOWED_LIST = Set.new(
+          %i[
+            unicode_normalized?
+            exclude?
+            empty?
+            acts_like_string?
+            include?
+            is_utf8?
+            casecmp?
+            match?
+            starts_with?
+            ends_with?
+            start_with?
+            end_with?
+            valid_encoding?
+            ascii_only?
+            between?
+          ]
+        ).freeze
+
+        def on_send(node)
+          return unless node.receiver&.const_name == 'Rails'
+
+          parent = node.parent
+          return unless parent&.predicate_method?
+
+          return if ALLOWED_LIST.include?(parent.method_name)
+
+          add_offense(parent)
+        end
+      end
+    end
+  end
+end

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

@@ -24,45 +24,69 @@ module RuboCop
 
         minimum_target_rails_version 7.1
 
-        # @!method rails_env_local_or?(node)
-        def_node_matcher :rails_env_local_or?, <<~PATTERN
-          (or
-            (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-            (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-          )
+        # @!method rails_env_local?(node)
+        def_node_matcher :rails_env_local?, <<~PATTERN
+          (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
         PATTERN
 
-        # @!method rails_env_local_and?(node)
-        def_node_matcher :rails_env_local_and?, <<~PATTERN
-          (and
-            (send
-              (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-              :!)
-            (send
-              (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-              :!)
-          )
+        # @!method not_rails_env_local?(node)
+        def_node_matcher :not_rails_env_local?, <<~PATTERN
+          (send #rails_env_local? :!)
         PATTERN
 
         def on_or(node)
-          rails_env_local_or?(node) do |*environments|
-            next unless environments.to_set == LOCAL_ENVIRONMENTS
+          lhs, rhs = *node.children
+          return unless rails_env_local?(rhs)
 
-            add_offense(node) do |corrector|
-              corrector.replace(node, 'Rails.env.local?')
-            end
+          nodes = [rhs]
+
+          if rails_env_local?(lhs)
+            nodes << lhs
+          elsif lhs.or_type? && rails_env_local?(lhs.rhs)
+            nodes << lhs.rhs
+          end
+
+          return unless environments(nodes).to_set == LOCAL_ENVIRONMENTS
+
+          range = offense_range(nodes)
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'Rails.env.local?')
           end
         end
 
         def on_and(node)
-          rails_env_local_and?(node) do |*environments|
-            next unless environments.to_set == LOCAL_ENVIRONMENTS
+          lhs, rhs = *node.children
+          return unless not_rails_env_local?(rhs)
+
+          nodes = [rhs]
+
+          if not_rails_env_local?(lhs)
+            nodes << lhs
+          elsif lhs.operator_keyword? && not_rails_env_local?(lhs.rhs)
+            nodes << lhs.rhs
+          end
 
-            add_offense(node, message: MSG_NEGATED) do |corrector|
-              corrector.replace(node, '!Rails.env.local?')
-            end
+          return unless environments(nodes).to_set == LOCAL_ENVIRONMENTS
+
+          range = offense_range(nodes)
+          add_offense(range, message: MSG_NEGATED) do |corrector|
+            corrector.replace(range, '!Rails.env.local?')
           end
         end
+
+        private
+
+        def environments(nodes)
+          if nodes[0].method?(:!)
+            nodes.map { |node| node.receiver.method_name }
+          else
+            nodes.map(&:method_name)
+          end
+        end
+
+        def offense_range(nodes)
+          nodes[1].source_range.begin.join(nodes[0].source_range.end)
+        end
       end
     end
   end

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

@@ -3,12 +3,13 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks that Rails.env is compared using `.production?`-like
+      # Checks that `Rails.env` is compared using `.production?`-like
       # methods instead of equality against a string or symbol.
       #
       # @example
       #   # bad
       #   Rails.env == 'production'
+      #   Rails.env.to_sym == :production
       #
       #   # bad, always returns false
       #   Rails.env == :test
@@ -18,26 +19,40 @@ module RuboCop
       class EnvironmentComparison < Base
         extend AutoCorrector
 
-        MSG = 'Favor `%<bang>sRails.env.%<env>s?` over `%<source>s`.'
+        MSG = 'Favor `%<prefer>s` over `%<source>s`.'
 
         SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always evaluate to `false`.'
 
         RESTRICT_ON_SEND = %i[== !=].freeze
 
-        def_node_matcher :comparing_str_env_with_rails_env_on_lhs?, <<~PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            {:== :!=}
-            $str
-          )
+        def_node_matcher :comparing_env_with_rails_env_on_lhs?, <<~PATTERN
+          {
+            (send
+              (send (const {nil? cbase} :Rails) :env)
+              {:== :!=}
+              $str
+            )
+            (send
+              (send (send (const {nil? cbase} :Rails) :env) :to_sym)
+              {:== :!=}
+              $sym
+            )
+          }
         PATTERN
 
-        def_node_matcher :comparing_str_env_with_rails_env_on_rhs?, <<~PATTERN
-          (send
-            $str
-            {:== :!=}
-            (send (const {nil? cbase} :Rails) :env)
-          )
+        def_node_matcher :comparing_env_with_rails_env_on_rhs?, <<~PATTERN
+          {
+            (send
+              $str
+              {:== :!=}
+              (send (const {nil? cbase} :Rails) :env)
+            )
+            (send
+              $sym
+              {:== :!=}
+              (send (send (const {nil? cbase} :Rails) :env) :to_sym)
+            )
+          }
         PATTERN
 
         def_node_matcher :comparing_sym_env_with_rails_env_on_lhs?, <<~PATTERN
@@ -56,59 +71,52 @@ module RuboCop
           )
         PATTERN
 
-        def_node_matcher :content, <<~PATTERN
-          ({str sym} $_)
-        PATTERN
-
         def on_send(node)
-          if (env_node = comparing_str_env_with_rails_env_on_lhs?(node) ||
-                         comparing_str_env_with_rails_env_on_rhs?(node))
-            env, = *env_node
-            bang = node.method?(:!=) ? '!' : ''
-            message = format(MSG, bang: bang, env: env, source: node.source)
-
-            add_offense(node, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
+          check_env_comparison_with_rails_env(node)
+          check_sym_env_comparison_with_rails_env(node)
+        end
+
+        private
+
+        def check_env_comparison_with_rails_env(node)
+          return unless comparing_env_with_rails_env_on_lhs?(node) || comparing_env_with_rails_env_on_rhs?(node)
+
+          replacement = build_predicate_method(node)
+          message = format(MSG, prefer: replacement, source: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
           end
+        end
 
+        def check_sym_env_comparison_with_rails_env(node)
           return unless comparing_sym_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_rhs?(node)
 
           add_offense(node, message: SYM_MSG) do |corrector|
-            autocorrect(corrector, node)
+            replacement = build_predicate_method(node)
+            corrector.replace(node, replacement)
           end
         end
 
-        private
+        def build_predicate_method(node)
+          bang = node.method?(:!=) ? '!' : ''
 
-        def autocorrect(corrector, node)
-          replacement = build_predicate_method(node)
+          receiver, argument = extract_receiver_and_argument(node)
+          receiver = receiver.receiver if receiver.method?(:to_sym)
 
-          corrector.replace(node, replacement)
+          "#{bang}#{receiver.source}.#{argument.value}?"
         end
 
-        def build_predicate_method(node)
+        def extract_receiver_and_argument(node)
           if rails_env_on_lhs?(node)
-            build_predicate_method_for_rails_env_on_lhs(node)
+            [node.receiver, node.first_argument]
           else
-            build_predicate_method_for_rails_env_on_rhs(node)
+            [node.first_argument, node.receiver]
           end
         end
 
         def rails_env_on_lhs?(node)
-          comparing_str_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_lhs?(node)
-        end
-
-        def build_predicate_method_for_rails_env_on_lhs(node)
-          bang = node.method?(:!=) ? '!' : ''
-
-          "#{bang}#{node.receiver.source}.#{content(node.first_argument)}?"
-        end
-
-        def build_predicate_method_for_rails_env_on_rhs(node)
-          bang = node.method?(:!=) ? '!' : ''
-
-          "#{bang}#{node.first_argument.source}.#{content(node.receiver)}?"
+          comparing_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_lhs?(node)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # Enforces that `exit` calls are not used within a rails app.
+      # Enforces that `exit` and `abort` calls are not used within a rails app.
       # Valid options are instead to raise an error, break, return, or some
       # other form of stopping execution of current request.
       #
@@ -26,12 +26,15 @@ module RuboCop
       class Exit < Base
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `exit` in Rails applications.'
-        RESTRICT_ON_SEND = %i[exit exit!].freeze
+        MSG = 'Do not use `%<current>s` in Rails applications.'
+        RESTRICT_ON_SEND = %i[exit exit! abort].freeze
         EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
 
         def on_send(node)
-          add_offense(node.loc.selector) if offending_node?(node)
+          return unless offending_node?(node)
+
+          message = format(MSG, current: node.method_name)
+          add_offense(node.loc.selector, message: message)
         end
 
         private

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

@@ -190,7 +190,7 @@ module RuboCop
           else
             replace_with_rails_root_join(corrector, rails_root_node, argument_source)
           end
-          node.children[rails_root_index + 1..].each { |child| corrector.remove(child) }
+          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)
@@ -281,7 +281,7 @@ module RuboCop
         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)
+          node.children[(rails_root_index + 1)..].map(&:source).join.delete_prefix(File::SEPARATOR)
         end
 
         def extension_node?(node)

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

@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def where_method?(receiver)
-          return false unless receiver
+          return false if !receiver || receiver.any_block_type?
 
           receiver.respond_to?(:method?) && receiver.method?(:where)
         end