rubocop 0.48.1 → 1.16.0

data/lib/rubocop/cop/style/alias.rb

@@ -3,60 +3,84 @@
 module RuboCop
   module Cop
     module Style
-      # This cop finds uses of `alias` where `alias_method` would be more
-      # appropriate (or is simply preferred due to configuration), and vice
-      # versa.
-      # It also finds uses of `alias :symbol` rather than `alias bareword`.
-      class Alias < Cop
+      # This cop enforces the use of either `#alias` or `#alias_method`
+      # depending on configuration.
+      # It also flags uses of `alias :symbol` rather than `alias bareword`.
+      #
+      # @example EnforcedStyle: prefer_alias (default)
+      #   # bad
+      #   alias_method :bar, :foo
+      #   alias :bar :foo
+      #
+      #   # good
+      #   alias bar foo
+      #
+      # @example EnforcedStyle: prefer_alias_method
+      #   # bad
+      #   alias :bar :foo
+      #   alias bar foo
+      #
+      #   # good
+      #   alias_method :bar, :foo
+      class Alias < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
-        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'.freeze
-        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %s.'.freeze
-        MSG_SYMBOL_ARGS  = 'Use `alias %s` instead of `alias %s`.'.freeze
+        MSG_ALIAS = 'Use `alias_method` instead of `alias`.'
+        MSG_ALIAS_METHOD = 'Use `alias` instead of `alias_method` %<current>s.'
+        MSG_SYMBOL_ARGS  = 'Use `alias %<prefer>s` instead of `alias %<current>s`.'
+
+        RESTRICT_ON_SEND = %i[alias_method].freeze
 
         def on_send(node)
           return unless node.command?(:alias_method)
-          return if style == :prefer_alias_method
-          return if scope_type(node) == :dynamic
+          return unless style == :prefer_alias && alias_keyword_possible?(node)
 
-          msg = format(MSG_ALIAS_METHOD, lexical_scope_type(node))
-          add_offense(node, :selector, msg)
+          msg = format(MSG_ALIAS_METHOD, current: lexical_scope_type(node))
+          add_offense(node.loc.selector, message: msg) do |corrector|
+            autocorrect(corrector, node)
+          end
         end
 
         def on_alias(node)
-          # alias_method can't be used with global variables
-          return if node.each_child_node(:gvar).any?
-          # alias_method can't be used in instance_eval blocks
-          scope_type = scope_type(node)
-          return if scope_type == :instance_eval
-
-          if scope_type == :dynamic || style == :prefer_alias_method
-            add_offense(node, :keyword, MSG_ALIAS)
+          return unless alias_method_possible?(node)
+
+          if scope_type(node) == :dynamic || style == :prefer_alias_method
+            add_offense(node.loc.keyword, message: MSG_ALIAS) do |corrector|
+              autocorrect(corrector, node)
+            end
           elsif node.children.none? { |arg| bareword?(arg) }
-            add_offense_for_args(node)
+            add_offense_for_args(node) { |corrector| autocorrect(corrector, node) }
           end
         end
 
-        def add_offense_for_args(node)
-          existing_args  = node.children.map(&:source).join(' ')
-          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
-          arg_ranges     = node.children.map(&:source_range)
-          msg            = format(MSG_SYMBOL_ARGS, preferred_args,
-                                  existing_args)
-          add_offense(node, arg_ranges.reduce(&:join), msg)
-        end
+        private
 
-        def autocorrect(node)
+        def autocorrect(corrector, node)
           if node.send_type?
-            correct_alias_method_to_alias(node)
+            correct_alias_method_to_alias(corrector, node)
           elsif scope_type(node) == :dynamic || style == :prefer_alias_method
-            correct_alias_to_alias_method(node)
+            correct_alias_to_alias_method(corrector, node)
           else
-            correct_alias_with_symbol_args(node)
+            correct_alias_with_symbol_args(corrector, node)
           end
         end
 
-        private
+        def alias_keyword_possible?(node)
+          scope_type(node) != :dynamic && node.arguments.all?(&:sym_type?)
+        end
+
+        def alias_method_possible?(node)
+          scope_type(node) != :instance_eval && node.children.none?(&:gvar_type?)
+        end
+
+        def add_offense_for_args(node, &block)
+          existing_args  = node.children.map(&:source).join(' ')
+          preferred_args = node.children.map { |a| a.source[1..-1] }.join(' ')
+          arg_ranges     = node.children.map(&:source_range)
+          msg            = format(MSG_SYMBOL_ARGS, prefer: preferred_args, current: existing_args)
+          add_offense(arg_ranges.reduce(&:join), message: msg, &block)
+        end
 
         # In this expression, will `self` be the same as the innermost enclosing
         # class or module block (:lexical)? Or will it be something else
@@ -69,7 +93,7 @@ module RuboCop
             when :def, :defs
               return :dynamic
             when :block
-              return :instance_eval if parent.method_name == :instance_eval
+              return :instance_eval if parent.method?(:instance_eval)
 
               return :dynamic
             end
@@ -79,40 +103,45 @@ module RuboCop
         end
 
         def lexical_scope_type(node)
-          node.each_ancestor(:class, :module) do |ancestor|
-            return ancestor.class_type? ? 'in a class body' : 'in a module body'
+          ancestor = node.each_ancestor(:class, :module).first
+          if ancestor.nil?
+            'at the top level'
+          elsif ancestor.class_type?
+            'in a class body'
+          else
+            'in a module body'
           end
-          'at the top level'
         end
 
         def bareword?(sym_node)
           !sym_node.source.start_with?(':')
         end
 
-        def correct_alias_method_to_alias(send_node)
-          lambda do |corrector|
-            new, old = *send_node.arguments
-            replacement = "alias #{new.children.first} #{old.children.first}"
-            corrector.replace(send_node.source_range, replacement)
-          end
+        def correct_alias_method_to_alias(corrector, send_node)
+          new, old = *send_node.arguments
+          replacement = "alias #{identifier(new)} #{identifier(old)}"
+
+          corrector.replace(send_node, replacement)
         end
 
-        def correct_alias_to_alias_method(node)
-          lambda do |corrector|
-            new, old = *node
-            replacement = "alias_method :#{new.children.first}, " \
-                          ":#{old.children.first}"
-            corrector.replace(node.source_range, replacement)
-          end
+        def correct_alias_to_alias_method(corrector, node)
+          replacement =
+            'alias_method ' \
+            ":#{identifier(node.new_identifier)}, " \
+            ":#{identifier(node.old_identifier)}"
+
+          corrector.replace(node, replacement)
         end
 
-        def correct_alias_with_symbol_args(node)
-          lambda do |corrector|
-            new, old = *node
-            corrector.replace(new.source_range, new.children.first.to_s)
-            corrector.replace(old.source_range, old.children.first.to_s)
-          end
+        def correct_alias_with_symbol_args(corrector, node)
+          corrector.replace(node.new_identifier, node.new_identifier.source[1..-1])
+          corrector.replace(node.old_identifier, node.old_identifier.source[1..-1])
         end
+
+        # @!method identifier(node)
+        def_node_matcher :identifier, <<~PATTERN
+          (sym $_)
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/style/and_or.rb

@@ -3,85 +3,106 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for uses of *and* and *or*.
-      class AndOr < Cop
+      # This cop checks for uses of `and` and `or`, and suggests using `&&` and
+      # `||` instead. It can be configured to check only in conditions or in
+      # all contexts.
+      #
+      # @example EnforcedStyle: always
+      #   # bad
+      #   foo.save and return
+      #
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
+      #
+      # @example EnforcedStyle: conditionals (default)
+      #   # bad
+      #   if foo and bar
+      #   end
+      #
+      #   # good
+      #   foo.save && return
+      #
+      #   # good
+      #   foo.save and return
+      #
+      #   # good
+      #   if foo && bar
+      #   end
+      class AndOr < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        extend AutoCorrector
 
-        MSG = 'Use `%s` instead of `%s`.'.freeze
-
-        OPS = { 'and' => '&&', 'or' => '||' }.freeze
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
 
         def on_and(node)
-          process_logical_op(node) if style == :always
-        end
-
-        def on_or(node)
-          process_logical_op(node) if style == :always
+          process_logical_operator(node) if style == :always
         end
+        alias on_or on_and
 
         def on_if(node)
           on_conditionals(node) if style == :conditionals
         end
-
-        def on_while(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_while_post(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_until(node)
-          on_conditionals(node) if style == :conditionals
-        end
-
-        def on_until_post(node)
-          on_conditionals(node) if style == :conditionals
-        end
+        alias on_while      on_if
+        alias on_while_post on_if
+        alias on_until      on_if
+        alias on_until_post on_if
 
         private
 
-        def on_conditionals(node)
-          node.condition.each_node(*LOGICAL_OPERATOR_NODES) do |logical_node|
-            process_logical_op(logical_node)
-          end
-        end
-
-        def process_logical_op(node)
+        def process_logical_operator(node)
           return if node.logical_operator?
 
-          add_offense(node, :operator,
-                      format(MSG, node.alternate_operator, node.operator))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            [*node].each do |expr|
+          message = message(node)
+          add_offense(node.loc.operator, message: message) do |corrector|
+            node.each_child_node do |expr|
               if expr.send_type?
                 correct_send(expr, corrector)
-              elsif expr.return_type?
-                correct_other(expr, corrector)
-              elsif expr.assignment?
+              elsif expr.return_type? || expr.assignment?
                 correct_other(expr, corrector)
               end
             end
 
             corrector.replace(node.loc.operator, node.alternate_operator)
+
+            keep_operator_precedence(corrector, node)
+          end
+        end
+
+        def on_conditionals(node)
+          node.condition.each_node(*AST::Node::OPERATOR_KEYWORDS) do |operator|
+            process_logical_operator(operator)
           end
         end
 
+        def message(node)
+          format(MSG, prefer: node.alternate_operator, current: node.operator)
+        end
+
         def correct_send(node, corrector)
           return correct_not(node, node.receiver, corrector) if node.method?(:!)
           return correct_setter(node, corrector) if node.setter_method?
+          return correct_other(node, corrector) if node.comparison_method?
+
           return unless correctable_send?(node)
 
-          corrector.replace(whitespace_before_arg(node), '('.freeze)
-          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+          whitespace_before_arg_range = whitespace_before_arg(node)
+          corrector.remove(whitespace_before_arg_range)
+          corrector.insert_before(whitespace_before_arg_range, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         def correct_setter(node, corrector)
-          corrector.insert_before(node.receiver.source_range, '('.freeze)
-          corrector.insert_after(node.last_argument.source_range, ')'.freeze)
+          corrector.insert_before(node.receiver, '(')
+          corrector.insert_after(node.last_argument, ')')
         end
 
         # ! is a special case:
@@ -89,11 +110,11 @@ module RuboCop
         # recurse down a level and add parens to 'obj.method arg'
         # however, 'not x' also parses as (send x :!)
         def correct_not(node, receiver, corrector)
-          if node.keyword_bang?
+          if node.prefix_bang?
             return unless receiver.send_type?
 
             correct_send(receiver, corrector)
-          elsif node.keyword_not?
+          elsif node.prefix_not?
             correct_other(node, corrector)
           else
             raise 'unrecognized unary negation operator'
@@ -103,12 +124,19 @@ module RuboCop
         def correct_other(node, corrector)
           return if node.source_range.begin.is?('(')
 
-          corrector.insert_before(node.source_range, '(')
-          corrector.insert_after(node.source_range, ')')
+          corrector.wrap(node, '(', ')')
+        end
+
+        def keep_operator_precedence(corrector, node)
+          if node.or_type? && node.parent&.and_type?
+            corrector.wrap(node, '(', ')')
+          elsif node.and_type? && node.rhs.or_type?
+            corrector.wrap(node.rhs, '(', ')')
+          end
         end
 
         def correctable_send?(node)
-          !node.parenthesized? && node.arguments?
+          !node.parenthesized? && node.arguments? && !node.method?(:[])
         end
 
         def whitespace_before_arg(node)
@@ -116,7 +144,7 @@ module RuboCop
           end_paren = begin_paren
           # Increment position of parenthesis, unless message is a predicate
           # method followed by a non-whitespace char (e.g. is_a?String).
-          end_paren += 1 unless node.source =~ /\?\S/
+          end_paren += 1 unless /\?\S/.match?(node.source)
           range_between(begin_paren, end_paren)
         end
       end

data/lib/rubocop/cop/style/arguments_forwarding.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # In Ruby 2.7, arguments forwarding has been added.
+      #
+      # This cop identifies places where `do_something(*args, &block)`
+      # can be replaced by `do_something(...)`.
+      #
+      # @example
+      #   # bad
+      #   def foo(*args, &block)
+      #     bar(*args, &block)
+      #   end
+      #
+      #   # bad
+      #   def foo(*args, **kwargs, &block)
+      #     bar(*args, **kwargs, &block)
+      #   end
+      #
+      #   # good
+      #   def foo(...)
+      #     bar(...)
+      #   end
+      #
+      # @example AllowOnlyRestArgument: true (default)
+      #   # good
+      #   def foo(*args)
+      #     bar(*args)
+      #   end
+      #
+      # @example AllowOnlyRestArgument: false
+      #   # bad
+      #   # The following code can replace the arguments with `...`,
+      #   # but it will change the behavior. Because `...` forwards block also.
+      #   def foo(*args)
+      #     bar(*args)
+      #   end
+      #
+      class ArgumentsForwarding < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Use arguments forwarding.'
+
+        # @!method use_rest_arguments?(node)
+        def_node_matcher :use_rest_arguments?, <<~PATTERN
+          (args (restarg $_) $...)
+        PATTERN
+
+        # @!method only_rest_arguments?(node, name)
+        def_node_matcher :only_rest_arguments?, <<~PATTERN
+          (send _ _ (splat (lvar %1)))
+        PATTERN
+
+        # @!method forwarding_method_arguments?(node, rest_name, block_name, kwargs_name)
+        def_node_matcher :forwarding_method_arguments?, <<~PATTERN
+          {
+            (send _ _
+              (splat (lvar %1))
+              (block-pass (lvar %2)))
+            (send _ _
+              (splat (lvar %1))
+              (hash (kwsplat (lvar %3)))
+              (block-pass (lvar %2)))
+          }
+        PATTERN
+
+        def on_def(node)
+          return unless node.body
+          return unless (rest_args_name, args = use_rest_arguments?(node.arguments))
+
+          node.each_descendant(:send) do |send_node|
+            kwargs_name, block_name = extract_argument_names_from(args)
+
+            next unless forwarding_method?(send_node, rest_args_name, kwargs_name, block_name) &&
+                        all_lvars_as_forwarding_method_arguments?(node, send_node)
+
+            register_offense_to_forwarding_method_arguments(send_node)
+            register_offense_to_method_definition_arguments(node)
+          end
+        end
+        alias on_defs on_def
+
+        private
+
+        def extract_argument_names_from(args)
+          kwargs_name = args.first.source.delete('**') if args.first&.kwrestarg_type?
+          block_arg_name = args.last.source.delete('&') if args.last&.blockarg_type?
+
+          [kwargs_name, block_arg_name].map { |name| name&.to_sym }
+        end
+
+        def forwarding_method?(node, rest_arg, kwargs, block_arg)
+          return only_rest_arguments?(node, rest_arg) unless allow_only_rest_arguments?
+
+          forwarding_method_arguments?(node, rest_arg, block_arg, kwargs)
+        end
+
+        def all_lvars_as_forwarding_method_arguments?(def_node, forwarding_method)
+          lvars = def_node.body.each_descendant(:lvar, :lvasgn)
+
+          begin_pos = forwarding_method.source_range.begin_pos
+          end_pos = forwarding_method.source_range.end_pos
+
+          lvars.all? { |lvar| lvar.source_range.begin_pos.between?(begin_pos, end_pos) }
+        end
+
+        def register_offense_to_forwarding_method_arguments(forwarding_method)
+          add_offense(arguments_range(forwarding_method)) do |corrector|
+            range = range_between(
+              forwarding_method.loc.selector.end_pos, forwarding_method.source_range.end_pos
+            )
+            corrector.replace(range, '(...)')
+          end
+        end
+
+        def register_offense_to_method_definition_arguments(method_definition)
+          add_offense(arguments_range(method_definition)) do |corrector|
+            arguments_range = range_with_surrounding_space(
+              range: method_definition.arguments.source_range, side: :left
+            )
+            corrector.replace(arguments_range, '(...)')
+          end
+        end
+
+        def arguments_range(node)
+          arguments = node.arguments
+
+          range_between(arguments.first.source_range.begin_pos, arguments.last.source_range.end_pos)
+        end
+
+        def allow_only_rest_arguments?
+          cop_config.fetch('AllowOnlyRestArgument', true)
+        end
+      end
+    end
+  end
+end