rubocop-rails 2.7.1 → 2.10.0

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

@@ -40,8 +40,9 @@ module RuboCop
       #
       #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
       #   end
-      class CreateTableWithTimestamps < Cop
+      class CreateTableWithTimestamps < Base
         MSG = 'Add timestamps when creating a new table.'
+        RESTRICT_ON_SEND = %i[create_table].freeze
 
         def_node_matcher :create_table_with_block?, <<~PATTERN
           (block

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

@@ -43,7 +43,7 @@ module RuboCop
       #   Date.yesterday
       #   date.in_time_zone
       #
-      class Date < Cop
+      class Date < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
@@ -52,6 +52,8 @@ module RuboCop
         MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
                    'know nothing about the time zone in use.'
 
+        RESTRICT_ON_SEND = %i[to_time to_time_in_current_zone].freeze
+
         BAD_DAYS = %i[today current yesterday tomorrow].freeze
 
         DEPRECATED_METHODS = [
@@ -76,8 +78,7 @@ module RuboCop
 
           check_deprecated_methods(node)
 
-          add_offense(node, location: :selector,
-                            message: format(MSG_SEND, method: node.method_name))
+          add_offense(node.loc.selector, message: format(MSG_SEND, method: node.method_name))
         end
         alias on_csend on_send
 
@@ -87,10 +88,9 @@ module RuboCop
           DEPRECATED_METHODS.each do |method|
             next unless node.method?(method[:deprecated].to_sym)
 
-            add_offense(node, location: :selector,
-                              message: format(DEPRECATED_MSG,
-                                              deprecated: method[:deprecated],
-                                              relevant: method[:relevant]))
+            message = format(DEPRECATED_MSG, deprecated: method[:deprecated], relevant: method[:relevant])
+
+            add_offense(node.loc.selector, message: message)
           end
         end
 
@@ -104,10 +104,9 @@ module RuboCop
           day = method_name
           day = 'today' if method_name == 'current'
 
-          add_offense(node, location: :selector,
-                            message: format(MSG,
-                                            method_called: method_name,
-                                            day: day))
+          message = format(MSG, method_called: method_name, day: day)
+
+          add_offense(node.loc.selector, message: message)
         end
 
         def extract_method_chain(node)

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

@@ -22,8 +22,9 @@ module RuboCop
       #     where(hidden: false)
       #   end
       #
-      class DefaultScope < Cop
+      class DefaultScope < Base
         MSG = 'Avoid use of `default_scope`. It is better to use explicitly named scopes.'
+        RESTRICT_ON_SEND = %i[default_scope].freeze
 
         def_node_matcher :method_call?, <<~PATTERN
           (send nil? :default_scope ...)
@@ -38,15 +39,21 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          add_offense(node, location: :selector) if method_call?(node)
+          return unless method_call?(node)
+
+          add_offense(node.loc.selector)
         end
 
         def on_defs(node)
-          add_offense(node, location: :name) if class_method_definition?(node)
+          return unless class_method_definition?(node)
+
+          add_offense(node.loc.name)
         end
 
         def on_sclass(node)
-          eigenclass_method_definition?(node) { |default_scope| add_offense(default_scope, location: :name) }
+          eigenclass_method_definition?(node) do |default_scope|
+            add_offense(default_scope.loc.name)
+          end
         end
       end
     end

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

@@ -52,7 +52,9 @@ module RuboCop
       #
       #   # good
       #   delegate :bar, to: :foo, prefix: true
-      class Delegate < Cop
+      class Delegate < Base
+        extend AutoCorrector
+
         MSG = 'Use `delegate` to define delegations.'
 
         def_node_matcher :delegate?, <<~PATTERN
@@ -64,22 +66,20 @@ module RuboCop
           return unless trivial_delegate?(node)
           return if private_or_protected_delegation(node)
 
-          add_offense(node, location: :keyword)
+          register_offense(node)
         end
 
-        def autocorrect(node)
-          delegation = ["delegate :#{node.body.method_name}",
-                        "to: :#{node.body.receiver.method_name}"]
+        private
 
-          delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
+        def register_offense(node)
+          add_offense(node.loc.keyword) do |corrector|
+            delegation = ["delegate :#{node.body.method_name}", "to: :#{node.body.receiver.method_name}"]
+            delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
 
-          lambda do |corrector|
             corrector.replace(node.source_range, delegation.join(', '))
           end
         end
 
-        private
-
         def trivial_delegate?(def_node)
           delegate?(def_node) &&
             method_name_matches?(def_node.method_name, def_node.body) &&

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

@@ -13,22 +13,21 @@ module RuboCop
       #
       #   # good
       #   delegate :foo, to: :bar, allow_nil: true
-      class DelegateAllowBlank < Cop
+      class DelegateAllowBlank < Base
+        extend AutoCorrector
+
         MSG = '`allow_blank` is not a valid option, use `allow_nil`.'
+        RESTRICT_ON_SEND = %i[delegate].freeze
 
         def_node_matcher :allow_blank_option, <<~PATTERN
           (send nil? :delegate _ (hash <$(pair (sym :allow_blank) true) ...>))
         PATTERN
 
         def on_send(node)
-          allow_blank_option(node) do |offending_node|
-            add_offense(offending_node)
-          end
-        end
+          return unless (offending_node = allow_blank_option(node))
 
-        def autocorrect(pair_node)
-          lambda do |corrector|
-            corrector.replace(pair_node.key.source_range, 'allow_nil')
+          add_offense(offending_node) do |corrector|
+            corrector.replace(offending_node.key.source_range, 'allow_nil')
           end
         end
       end

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

@@ -31,36 +31,39 @@ module RuboCop
       #
       #   # good
       #   Gem::Specification.find_by_name('backend').gem_dir
-      class DynamicFindBy < Cop
+      class DynamicFindBy < Base
+        include ActiveRecordHelper
+        extend AutoCorrector
+
         MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
 
         def on_send(node)
-          return if allowed_invocation?(node)
+          return if node.receiver.nil? && !inherit_active_record_base?(node) || allowed_invocation?(node)
 
           method_name = node.method_name
           static_name = static_method_name(method_name)
           return unless static_name
+          return if node.arguments.any?(&:splat_type?)
 
-          add_offense(node,
-                      message: format(MSG, static_name: static_name,
-                                           method: method_name))
+          message = format(MSG, static_name: static_name, method: method_name)
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           keywords = column_keywords(node.method_name)
 
           return if keywords.size != node.arguments.size
 
-          lambda do |corrector|
-            autocorrect_method_name(corrector, node)
-            autocorrect_argument_keywords(corrector, node, keywords)
-          end
+          autocorrect_method_name(corrector, node)
+          autocorrect_argument_keywords(corrector, node, keywords)
         end
 
-        private
-
         def allowed_invocation?(node)
           allowed_method?(node) || allowed_receiver?(node) ||
             whitelisted?(node)

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

@@ -17,9 +17,12 @@ module RuboCop
       #   # good
       #   enum status: { active: 0, archived: 1 }
       #
-      class EnumHash < Cop
+      class EnumHash < Base
+        extend AutoCorrector
+
         MSG = 'Enum defined as an array found in `%<enum>s` enum declaration. '\
               'Use hash syntax instead.'
+        RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
           (send nil? :enum (hash $...))
@@ -35,19 +38,17 @@ module RuboCop
               key, array = array_pair?(pair)
               next unless key
 
-              add_offense(array, message: format(MSG, enum: enum_name(key)))
+              add_offense(array, message: format(MSG, enum: enum_name(key))) do |corrector|
+                hash = array.children.each_with_index.map do |elem, index|
+                  "#{source(elem)} => #{index}"
+                end.join(', ')
+
+                corrector.replace(array.loc.expression, "{#{hash}}")
+              end
             end
           end
         end
 
-        def autocorrect(node)
-          hash = node.children.each_with_index.map do |elem, index|
-            "#{source(elem)} => #{index}"
-          end.join(', ')
-
-          ->(corrector) { corrector.replace(node.loc.expression, "{#{hash}}") }
-        end
-
         private
 
         def enum_name(key)

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

@@ -17,11 +17,12 @@ module RuboCop
       #
       #   # good
       #   enum status: [:active, :archived]
-      class EnumUniqueness < Cop
+      class EnumUniqueness < Base
         include Duplication
 
         MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
               'enum declaration.'
+        RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
           (send nil? :enum (hash $...))

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

@@ -15,12 +15,16 @@ module RuboCop
       #
       #   # good
       #   Rails.env.production?
-      class EnvironmentComparison < Cop
+      class EnvironmentComparison < Base
+        extend AutoCorrector
+
         MSG = 'Favor `%<bang>sRails.env.%<env>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)
@@ -62,28 +66,28 @@ module RuboCop
                          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: format(
-              MSG, bang: bang, env: env, source: node.source
-            ))
-          end
-
-          if comparing_sym_env_with_rails_env_on_lhs?(node) ||
-             comparing_sym_env_with_rails_env_on_rhs?(node)
-            add_offense(node, message: SYM_MSG)
+            add_offense(node, message: message) do |corrector|
+              autocorrect(corrector, node)
+            end
           end
-        end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            replacement = build_predicate_method(node)
+          return unless comparing_sym_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_rhs?(node)
 
-            corrector.replace(node.source_range, replacement)
+          add_offense(node, message: SYM_MSG) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 
         private
 
+        def autocorrect(corrector, node)
+          replacement = build_predicate_method(node)
+
+          corrector.replace(node.source_range, replacement)
+        end
+
         def build_predicate_method(node)
           if rails_env_on_lhs?(node)
             build_predicate_method_for_rails_env_on_lhs(node)

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # This cop looks for direct access to environment variables through the
+      # `ENV` variable within the application code. This can lead to runtime
+      # errors due to misconfiguration that could have been discovered at boot
+      # time if the environment variables were loaded as part of initialization
+      # and copied into the application's configuration or secrets. The cop can
+      # be configured to allow either reads or writes if required.
+      #
+      # @example
+      #   # good
+      #   Rails.application.config.foo
+      #   Rails.application.config.x.foo.bar
+      #   Rails.application.secrets.foo
+      #   Rails.application.config.foo = "bar"
+      #
+      # @example AllowReads: false (default)
+      #   # bad
+      #   ENV["FOO"]
+      #   ENV.fetch("FOO")
+      #
+      # @example AllowReads: true
+      #   # good
+      #   ENV["FOO"]
+      #   ENV.fetch("FOO")
+      #
+      # @example AllowWrites: false (default)
+      #   # bad
+      #   ENV["FOO"] = "bar"
+      #
+      # @example AllowWrites: true
+      #   # good
+      #   ENV["FOO"] = "bar"
+      class EnvironmentVariableAccess < Base
+        READ_MSG = 'Do not read from `ENV` directly post initialization.'
+        WRITE_MSG = 'Do not write to `ENV` directly post initialization.'
+
+        def on_const(node)
+          add_offense(node, message: READ_MSG) if env_read?(node) && !allow_reads?
+          add_offense(node, message: WRITE_MSG) if env_write?(node) && !allow_writes?
+        end
+
+        def_node_search :env_read?, <<~PATTERN
+          ^(send (const {cbase nil?} :ENV) !:[]= ...)
+        PATTERN
+
+        def_node_search :env_write?, <<~PATTERN
+          {^(indexasgn (const {cbase nil?} :ENV) ...)
+           ^(send (const {cbase nil?} :ENV) :[]= ...)}
+        PATTERN
+
+        private
+
+        def allow_reads?
+          cop_config['AllowReads'] == true
+        end
+
+        def allow_writes?
+          cop_config['AllowWrites'] == true
+        end
+      end
+    end
+  end
+end

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

@@ -23,27 +23,21 @@ module RuboCop
       #
       #   # good
       #   raise 'a bad error has happened'
-      class Exit < Cop
+      class Exit < Base
         include ConfigurableEnforcedStyle
 
         MSG = 'Do not use `exit` in Rails applications.'
-        TARGET_METHODS = %i[exit exit!].freeze
+        RESTRICT_ON_SEND = %i[exit exit!].freeze
         EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
 
         def on_send(node)
-          add_offense(node, location: :selector) if offending_node?(node)
+          add_offense(node.loc.selector) if offending_node?(node)
         end
 
         private
 
         def offending_node?(node)
-          right_method_name?(node.method_name) &&
-            right_argument_count?(node.arguments) &&
-            right_receiver?(node.receiver)
-        end
-
-        def right_method_name?(method_name)
-          TARGET_METHODS.include?(method_name)
+          right_argument_count?(node.arguments) && right_receiver?(node.receiver)
         end
 
         # More than 1 argument likely means it is a different

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

@@ -25,14 +25,13 @@ module RuboCop
       #   # good
       #   Rails.root.join('app/models/goober')
       #
-      class FilePath < Cop
+      class FilePath < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
-        MSG_SLASHES = 'Please use `Rails.root.join(\'path/to\')` ' \
-                      'instead.'
-        MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
-                        'instead.'
+        MSG_SLASHES = 'Prefer `Rails.root.join(\'path/to\')`.'
+        MSG_ARGUMENTS = 'Prefer `Rails.root.join(\'path\', \'to\')`.'
+        RESTRICT_ON_SEND = %i[join].freeze
 
         def_node_matcher :file_join_nodes?, <<~PATTERN
           (send (const nil? :File) :join ...)
@@ -90,17 +89,17 @@ module RuboCop
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source.match?(%r{/})
+          node.str_type? && node.source.include?('/')
         end
 
         def register_offense(node)
           line_range = node.loc.column...node.loc.last_column
           source_range = source_range(processed_source.buffer, node.first_line,
                                       line_range)
-          add_offense(node, location: source_range)
+          add_offense(source_range)
         end
 
-        def message(_node)
+        def message(_range)
           format(style == :arguments ? MSG_ARGUMENTS : MSG_SLASHES)
         end
       end