rubocop 0.52.1 → 0.53.0

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks that ActiveRecord aliases are not used. The direct method names
+      # are more clear and easier to read.
+      #
+      # @example
+      #   #bad
+      #   Book.update_attributes!(author: 'Alice')
+      #
+      #   #good
+      #   Book.update!(author: 'Alice')
+      class ActiveRecordAliases < Cop
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'.freeze
+
+        ALIASES = {
+          update_attributes: :update,
+          update_attributes!: :update!
+        }.freeze
+
+        def on_send(node)
+          ALIASES.each do |bad, good|
+            next unless node.method?(bad)
+
+            add_offense(node,
+                        message: format(MSG, prefer: good, current: bad),
+                        location: :selector,
+                        severity: :warning)
+            break
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(
+              node.loc.selector,
+              ALIASES[node.method_name].to_s
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -82,12 +82,12 @@ module RuboCop
         def on_or(node)
           return unless cop_config['NilOrEmpty']
 
-          nil_or_empty?(node) do |variable1, variable2|
-            return unless variable1 == variable2
+          nil_or_empty?(node) do |var1, var2|
+            return unless var1 == var2
 
             add_offense(node,
                         message: format(MSG_NIL_OR_EMPTY,
-                                        prefer: replacement(variable1),
+                                        prefer: replacement(var1),
                                         current: node.source))
           end
         end

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

@@ -50,6 +50,10 @@ module RuboCop
             _)
         PATTERN
 
+        def_node_matcher :create_table_with_timestamps_proc?, <<-PATTERN
+          (send nil? :create_table (sym _) (block-pass (sym :timestamps)))
+        PATTERN
+
         def_node_search :timestamps_included?, <<-PATTERN
           (send _var :timestamps ...)
         PATTERN
@@ -66,6 +70,8 @@ module RuboCop
             if parent.body.nil? || !time_columns_included?(parent.body)
               add_offense(parent)
             end
+          elsif create_table_with_timestamps_proc?(node)
+            # nothing to do
           else
             add_offense(node)
           end

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

@@ -55,6 +55,11 @@ module RuboCop
       class Delegate < Cop
         MSG = 'Use `delegate` to define delegations.'.freeze
 
+        def_node_matcher :delegate?, <<-PATTERN
+          (def _method_name _args
+            (send (send nil? _) _ ...))
+        PATTERN
+
         def on_def(node)
           return unless trivial_delegate?(node)
           return if private_or_protected_delegation(node)
@@ -81,16 +86,11 @@ module RuboCop
         def trivial_delegate?(def_node)
           method_name, args, body = *def_node
 
-          delegate?(body) &&
+          delegate?(def_node) &&
             method_name_matches?(method_name, body) &&
             arguments_match?(args, body)
         end
 
-        def delegate?(body)
-          body && body.send_type? && body.receiver &&
-            body.receiver.send_type? && !body.receiver.receiver
-        end
-
         def arguments_match?(arg_array, body)
           argument_array = body.arguments
 

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

@@ -4,7 +4,8 @@ module RuboCop
   module Cop
     module Rails
       # This cop is used to identify usages of file path joining process
-      # to use `Rails.root.join` clause.
+      # to use `Rails.root.join` clause. This is to avoid bugs on operating
+      # system that don't use '/' as the path separator.
       #
       # @example
       #  # bad
@@ -15,6 +16,8 @@ module RuboCop
       #  # good
       #  Rails.root.join('app', 'models', 'goober')
       class FilePath < Cop
+        include RangeHelp
+
         MSG = 'Please use `Rails.root.join(\'path\', \'to\')` instead.'.freeze
 
         def_node_matcher :file_join_nodes?, <<-PATTERN
@@ -31,6 +34,9 @@ module RuboCop
 
         def on_dstr(node)
           return unless rails_root_nodes?(node)
+          return unless node.children.last.source.start_with?('.') ||
+                        node.children.last.source.include?(File::SEPARATOR)
+
           register_offense(node)
         end
 

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

@@ -14,6 +14,8 @@ module RuboCop
       #   # good
       #   User.find_by(name: 'Bruce')
       class FindBy < Cop
+        include RangeHelp
+
         MSG = 'Use `find_by` instead of `where.%<method>s`.'.freeze
         TARGET_SELECTORS = %i[first take].freeze
 

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

@@ -60,12 +60,15 @@ module RuboCop
           # the range of the text to replace, which is the whole line
           code_to_replace = node.loc.expression
           # what to replace with
-          format = parentheses?(node) ? '%s(%s%s%s)' : '%s %s%s%s'
-          new_code = format(format, node.method_name, controller_action,
-                            params, headers)
+          format = parentheses_format(node)
+          new_code = format(format, name: node.method_name,
+                                    action: controller_action,
+                                    params: params, headers: headers)
           ->(corrector) { corrector.replace(code_to_replace, new_code) }
         end
 
+        private
+
         def needs_conversion?(data)
           return true unless data.hash_type?
 
@@ -87,14 +90,23 @@ module RuboCop
           return '' if data.hash_type? && data.empty?
 
           hash_data = if data.hash_type?
-                        format('{ %s }', data.pairs.map(&:source).join(', '))
+                        format('{ %<data>s }',
+                               data: data.pairs.map(&:source).join(', '))
                       else
                         # user supplies an object,
                         # no need to surround with braces
                         data.source
                       end
 
-          format(', %s: %s', type, hash_data)
+          format(', %<type>s: %<hash_data>s', type: type, hash_data: hash_data)
+        end
+
+        def parentheses_format(node)
+          if parentheses?(node)
+            '%<name>s(%<action>s%<params>s%<headers>s)'
+          else
+            '%<name>s %<action>s%<params>s%<headers>s'
+          end
         end
       end
     end

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

@@ -7,7 +7,8 @@ module RuboCop
       # ActiveRecord can't automatically determine the inverse association
       # because of a scope or the options used. This can result in unnecessary
       # queries in some circumstances. `:inverse_of` must be manually specified
-      # for associations to work in both ways, or set to `false` to opt-out.
+      # for associations to work in both ways, or set to `false` or `nil`
+      # to opt-out.
       #
       # @example
       #   # good
@@ -52,6 +53,24 @@ module RuboCop
       #     belongs_to :blog
       #   end
       #
+      #   # good
+      #   # When you don't want to use the inverse association.
+      #   class Blog < ApplicationRecord
+      #     has_many(:posts,
+      #       -> { order(published_at: :desc) },
+      #       inverse_of: false
+      #     )
+      #   end
+      #
+      #   # good
+      #   # You can also opt-out with specifying `inverse_of: nil`.
+      #   class Blog < ApplicationRecord
+      #     has_many(:posts,
+      #       -> { order(published_at: :desc) },
+      #       inverse_of: nil
+      #     )
+      #   end
+      #
       # @example
       #   # bad
       #   class Picture < ApplicationRecord
@@ -155,7 +174,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :inverse_of_option?, <<-PATTERN
-          (pair (sym :inverse_of) !nil)
+          (pair (sym :inverse_of) _)
         PATTERN
 
         def on_send(node)

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     module Rails
       # This cop checks that methods specified in the filter's `only`
-      # or `except` options are explicitly defined in the controller.
+      # or `except` options are explicitly defined in the class or module.
       #
       # You can specify methods of superclass or methods added by mixins
       # on the filter, but these confuse developers. If you specify methods
-      # where are defined on another controller, you should define the filter
-      # in that controller.
+      # where are defined on another classes or modules, you should define
+      # the filter in that class or module.
       #
       # @example
       #   # bad
@@ -33,8 +33,31 @@ module RuboCop
       #     def logout
       #     end
       #   end
+      #
+      # @example
+      #   # bad
+      #   module FooMixin
+      #     extend ActiveSupport::Concern
+      #
+      #     included do
+      #       before_action proc { authenticate }, only: :foo
+      #     end
+      #   end
+      #
+      #   # good
+      #   module FooMixin
+      #     extend ActiveSupport::Concern
+      #
+      #     included do
+      #       before_action proc { authenticate }, only: :foo
+      #     end
+      #
+      #     def foo
+      #       # something
+      #     end
+      #   end
       class LexicallyScopedActionFilter < Cop
-        MSG = '%<action>s not explicitly defined on the controller.'.freeze
+        MSG = '%<action>s not explicitly defined on the %<type>s.'.freeze
 
         FILTERS = %w[
           :after_action
@@ -67,12 +90,18 @@ module RuboCop
           methods_node = only_or_except_filter_methods(node)
           return unless methods_node
 
-          defined_methods = node.parent.each_child_node(:def).map(&:method_name)
+          parent = node.each_ancestor(:class, :module).first
+          return unless parent
+          block = parent.each_child_node(:begin).first
+          return unless block
+
+          defined_methods = block.each_child_node(:def).map(&:method_name)
           methods = array_values(methods_node).reject do |method|
             defined_methods.include?(method)
           end
 
-          add_offense(node, message: message(methods)) unless methods.empty?
+          message = message(methods, parent)
+          add_offense(node, message: message) unless methods.empty?
         end
 
         private
@@ -99,11 +128,18 @@ module RuboCop
           end
         end
 
-        def message(methods)
+        # @param methods [Array<String>]
+        # @param parent [RuboCop::AST::Node]
+        # @return [String]
+        def message(methods, parent)
           if methods.size == 1
-            format(MSG, action: "`#{methods[0]}` is")
+            format(MSG,
+                   action: "`#{methods[0]}` is",
+                   type: parent.type)
           else
-            format(MSG, action: "`#{methods.join('`, `')}` are")
+            format(MSG,
+                   action: "`#{methods.join('`, `')}` are",
+                   type: parent.type)
           end
         end
       end

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

@@ -71,14 +71,16 @@ module RuboCop
         PATTERN
 
         def on_if(node)
+          return if ignore_if_node?(node)
+
           redundant_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other)
+            unless ignore_other_node?(other) || receiver.nil?
               add_offense(node, message: message(node, receiver, other))
             end
           end
 
           redundant_negative_receiver_and_other(node) do |receiver, other|
-            unless ignore_other_node?(other)
+            unless ignore_other_node?(other) || receiver.nil?
               add_offense(node, message: message(node, receiver, other))
             end
           end
@@ -98,6 +100,10 @@ module RuboCop
 
         private
 
+        def ignore_if_node?(node)
+          node.elsif?
+        end
+
         def ignore_other_node?(node)
           node && (node.if_type? || node.rescue_type? || node.while_type?)
         end

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

@@ -75,12 +75,12 @@ module RuboCop
         def on_and(node)
           return unless cop_config['NotNilAndNotEmpty']
 
-          exists_and_not_empty?(node) do |variable1, variable2|
-            return unless variable1 == variable2
+          exists_and_not_empty?(node) do |var1, var2|
+            return unless var1 == var2
 
             add_offense(node,
                         message: format(MSG_EXISTS_AND_NOT_EMPTY,
-                                        prefer: replacement(variable1),
+                                        prefer: replacement(var1),
                                         current: node.source))
           end
         end
@@ -88,8 +88,8 @@ module RuboCop
         def on_or(node)
           return unless cop_config['NilOrEmpty']
 
-          exists_and_not_empty?(node) do |variable1, variable2|
-            return unless variable1 == variable2
+          exists_and_not_empty?(node) do |var1, var2|
+            return unless var1 == var2
 
             add_offense(node, message: MSG_EXISTS_AND_NOT_EMPTY)
           end

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

@@ -16,7 +16,7 @@ module RuboCop
       #   x = self[:attr]
       #   self[:attr] = val
       class ReadWriteAttribute < Cop
-        MSG = 'Prefer `%s` over `%s`.'.freeze
+        MSG = 'Prefer `%<prefer>s` over `%<current>s`.'.freeze
 
         def_node_matcher :read_write_attribute?, <<-PATTERN
           {
@@ -46,9 +46,10 @@ module RuboCop
 
         def message(node)
           if node.method?(:read_attribute)
-            format(MSG, 'self[:attr]', 'read_attribute(:attr)')
+            format(MSG, prefer: 'self[:attr]', current: 'read_attribute(:attr)')
           else
-            format(MSG, 'self[:attr] = val', 'write_attribute(:attr, val)')
+            format(MSG, prefer: 'self[:attr] = val',
+                        current: 'write_attribute(:attr, val)')
           end
         end
 

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

@@ -56,6 +56,7 @@ module RuboCop
       #   end
       class RedundantReceiverInWithOptions < Cop
         extend TargetRailsVersion
+        include RangeHelp
 
         minimum_target_rails_version 4.2
 

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

@@ -19,8 +19,8 @@ module RuboCop
       #     end
       #   end
       class RelativeDateConstant < Cop
-        MSG = 'Do not assign %s to constants as it will be evaluated only ' \
-              'once.'.freeze
+        MSG = 'Do not assign %<method_name>s to constants as it ' \
+              'will be evaluated only once.'.freeze
 
         RELATIVE_DATE_METHODS = %i[ago from_now since until].freeze
 
@@ -72,7 +72,8 @@ module RuboCop
 
           nodes.each do |n|
             if relative_date_method?(n)
-              add_offense(node.parent, message: format(MSG, n.method_name))
+              add_offense(node.parent,
+                          message: format(MSG, method_name: n.method_name))
             end
           end
         end

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

@@ -22,7 +22,8 @@ module RuboCop
       class RequestReferer < Cop
         include ConfigurableEnforcedStyle
 
-        MSG = 'Use `request.%s` instead of `request.%s`.'.freeze
+        MSG = 'Use `request.%<prefer>s` instead of ' \
+              '`request.%<current>s`.'.freeze
 
         def_node_matcher :referer?, <<-PATTERN
           (send (send nil? :request) {:referer :referrer})
@@ -43,7 +44,7 @@ module RuboCop
         private
 
         def message(_node)
-          format(MSG, style, wrong_method_name)
+          format(MSG, prefer: style, current: wrong_method_name)
         end
 
         def wrong_method_name