rubocop-rails 2.8.1 → 2.9.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,7 +31,9 @@ module RuboCop
       #
       #   # good
       #   Gem::Specification.find_by_name('backend').gem_dir
-      class DynamicFindBy < Cop
+      class DynamicFindBy < Base
+        extend AutoCorrector
+
         MSG = 'Use `%<static_name>s` instead of dynamic `%<method>s`.'
         METHOD_PATTERN = /^find_by_(.+?)(!)?$/.freeze
 
@@ -43,25 +45,24 @@ module RuboCop
           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/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,7 +25,7 @@ module RuboCop
       #   # good
       #   Rails.root.join('app/models/goober')
       #
-      class FilePath < Cop
+      class FilePath < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
 
@@ -33,6 +33,7 @@ module RuboCop
                       'instead.'
         MSG_ARGUMENTS = 'Please use `Rails.root.join(\'path\', \'to\')` ' \
                         'instead.'
+        RESTRICT_ON_SEND = %i[join].freeze
 
         def_node_matcher :file_join_nodes?, <<~PATTERN
           (send (const nil? :File) :join ...)
@@ -97,10 +98,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