rubocop-rails 2.8.0 → 2.10.1

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 ...)
@@ -97,10 +96,10 @@ module RuboCop
           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

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

@@ -13,11 +13,12 @@ module RuboCop
       #
       #   # good
       #   User.find_by(name: 'Bruce')
-      class FindBy < Cop
+      class FindBy < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `find_by` instead of `where.%<method>s`.'
-        TARGET_SELECTORS = %i[first take].freeze
+        RESTRICT_ON_SEND = %i[first take].freeze
 
         def_node_matcher :where_first?, <<~PATTERN
           (send ({send csend} _ :where ...) {:first :take})
@@ -26,28 +27,27 @@ module RuboCop
         def on_send(node)
           return unless where_first?(node)
 
-          range = range_between(node.receiver.loc.selector.begin_pos,
-                                node.loc.selector.end_pos)
+          range = range_between(node.receiver.loc.selector.begin_pos, node.loc.selector.end_pos)
 
-          add_offense(node, location: range,
-                            message: format(MSG, method: node.method_name))
+          add_offense(range, message: format(MSG, method: node.method_name)) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
         alias on_csend on_send
 
-        def autocorrect(node)
+        private
+
+        def autocorrect(corrector, node)
           # Don't autocorrect where(...).first, because it can return different
           # results from find_by. (They order records differently, so the
           # 'first' record can be different.)
           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.loc.dot.begin_pos, node.loc.selector.end_pos)
 
-          lambda do |corrector|
-            corrector.replace(where_loc, 'find_by')
-            corrector.replace(first_loc, '')
-          end
+          corrector.replace(where_loc, 'find_by')
+          corrector.replace(first_loc, '')
         end
       end
     end

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

@@ -16,10 +16,12 @@ module RuboCop
       #   # good
       #   User.find(id)
       #
-      class FindById < Cop
+      class FindById < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use `%<good_method>s` instead of `%<bad_method>s`.'
+        RESTRICT_ON_SEND = %i[take! find_by_id! find_by!].freeze
 
         def_node_matcher :where_take?, <<~PATTERN
           (send
@@ -38,41 +40,30 @@ module RuboCop
         def on_send(node)
           where_take?(node) do |where, id_value|
             range = where_take_offense_range(node, where)
-
-            good_method = build_good_method(id_value)
             bad_method = build_where_take_bad_method(id_value)
-            message = format(MSG, good_method: good_method, bad_method: bad_method)
 
-            add_offense(node, location: range, message: message)
+            register_offense(range, id_value, bad_method)
           end
 
           find_by?(node) do |id_value|
             range = find_by_offense_range(node)
-
-            good_method = build_good_method(id_value)
             bad_method = build_find_by_bad_method(node, id_value)
-            message = format(MSG, good_method: good_method, bad_method: bad_method)
 
-            add_offense(node, location: range, message: message)
+            register_offense(range, id_value, bad_method)
           end
         end
 
-        def autocorrect(node)
-          if (matches = where_take?(node))
-            where, id_value = *matches
-            range = where_take_offense_range(node, where)
-          elsif (id_value = find_by?(node))
-            range = find_by_offense_range(node)
-          end
+        private
+
+        def register_offense(range, id_value, bad_method)
+          good_method = build_good_method(id_value)
+          message = format(MSG, good_method: good_method, bad_method: bad_method)
 
-          lambda do |corrector|
-            replacement = build_good_method(id_value)
-            corrector.replace(range, replacement)
+          add_offense(range, message: message) do |corrector|
+            corrector.replace(range, good_method)
           end
         end
 
-        private
-
         def where_take_offense_range(node, where)
           range_between(where.loc.selector.begin_pos, node.loc.expression.end_pos)
         end

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

@@ -12,38 +12,39 @@ module RuboCop
       #
       #   # good
       #   User.all.find_each
-      class FindEach < Cop
+      #
+      # @example IgnoredMethods: ['order']
+      #   # good
+      #   User.order(:foo).each
+      class FindEach < Base
+        include ActiveRecordHelper
+        extend AutoCorrector
+
         MSG = 'Use `find_each` instead of `each`.'
+        RESTRICT_ON_SEND = %i[each].freeze
 
         SCOPE_METHODS = %i[
           all eager_load includes joins left_joins left_outer_joins not preload
           references unscoped where
         ].freeze
-        IGNORED_METHODS = %i[order limit select].freeze
 
         def on_send(node)
-          return unless node.receiver&.send_type? &&
-                        node.method?(:each)
-
+          return unless node.receiver&.send_type?
           return unless SCOPE_METHODS.include?(node.receiver.method_name)
-          return if method_chain(node).any? { |m| ignored_by_find_each?(m) }
+          return if node.receiver.receiver.nil? && !inherit_active_record_base?(node)
+          return if ignored?(node)
 
-          add_offense(node, location: :selector)
-        end
-
-        def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.selector, 'find_each') }
+          range = node.loc.selector
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'find_each')
+          end
         end
 
         private
 
-        def method_chain(node)
-          node.each_node(:send).map(&:method_name)
-        end
-
-        def ignored_by_find_each?(relation_method)
-          # Active Record's #find_each ignores various extra parameters
-          IGNORED_METHODS.include?(relation_method)
+        def ignored?(node)
+          method_chain = node.each_node(:send).map(&:method_name)
+          (cop_config['IgnoredMethods'].map(&:to_sym) & method_chain).any?
         end
       end
     end

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

@@ -11,13 +11,14 @@ module RuboCop
       #
       #   # good
       #   # has_many :ingredients, through: :recipe_ingredients
-      class HasAndBelongsToMany < Cop
+      class HasAndBelongsToMany < Base
         MSG = 'Prefer `has_many :through` to `has_and_belongs_to_many`.'
+        RESTRICT_ON_SEND = %i[has_and_belongs_to_many].freeze
 
         def on_send(node)
           return unless node.command?(:has_and_belongs_to_many)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
       end
     end

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

@@ -5,7 +5,9 @@ module RuboCop
     module Rails
       # This cop looks for `has_many` or `has_one` associations that don't
       # specify a `:dependent` option.
-      # It doesn't register an offense if `:through` option was specified.
+      #
+      # It doesn't register an offense if `:through` or `dependent: nil`
+      # is specified, or if the model is read-only.
       #
       # @example
       #   # bad
@@ -18,10 +20,21 @@ module RuboCop
       #   class User < ActiveRecord::Base
       #     has_many :comments, dependent: :restrict_with_exception
       #     has_one :avatar, dependent: :destroy
+      #     has_many :articles, dependent: nil
       #     has_many :patients, through: :appointments
       #   end
-      class HasManyOrHasOneDependent < Cop
+      #
+      #   class User < ActiveRecord::Base
+      #     has_many :comments
+      #     has_one :avatar
+      #
+      #     def readonly?
+      #       true
+      #     end
+      #   end
+      class HasManyOrHasOneDependent < Base
         MSG = 'Specify a `:dependent` option.'
+        RESTRICT_ON_SEND = %i[has_many has_one].freeze
 
         def_node_search :active_resource_class?, <<~PATTERN
           (const (const nil? :ActiveResource) :Base)
@@ -36,7 +49,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :dependent_option?, <<~PATTERN
-          (pair (sym :dependent) !nil)
+          (pair (sym :dependent) {!nil (nil)})
         PATTERN
 
         def_node_matcher :present_option?, <<~PATTERN
@@ -50,20 +63,38 @@ module RuboCop
             (args) ...)
         PATTERN
 
+        def_node_matcher :association_extension_block?, <<~PATTERN
+          (block
+            (send nil? :has_many _)
+            (args) ...)
+        PATTERN
+
+        def_node_matcher :readonly?, <<~PATTERN
+          (def :readonly?
+            (args)
+            (true))
+        PATTERN
+
         def on_send(node)
-          return if active_resource?(node.parent)
+          return if active_resource?(node.parent) || readonly_model?(node)
           return if !association_without_options?(node) && valid_options?(association_with_options?(node))
           return if valid_options_in_with_options_block?(node)
 
-          add_offense(node, location: :selector)
+          add_offense(node.loc.selector)
         end
 
         private
 
+        def readonly_model?(node)
+          return false unless (parent = node.parent)
+
+          parent.each_descendant(:def).any? { |def_node| readonly?(def_node) }
+        end
+
         def valid_options_in_with_options_block?(node)
           return true unless node.parent
 
-          n = node.parent.begin_type? ? node.parent.parent : node.parent
+          n = node.parent.begin_type? || association_extension_block?(node.parent) ? node.parent.parent : node.parent
 
           contain_valid_options_in_with_options_block?(n)
         end