rubocop 0.51.0 → 0.87.0

data/lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style omit_parentheses
+        module OmitParentheses
+          TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+
+          def on_send(node)
+            return unless node.parenthesized?
+            return if node.implicit_call?
+            return if super_call_without_arguments?(node)
+            return if allowed_camel_case_method_call?(node)
+            return if legitimate_call_with_parentheses?(node)
+
+            add_offense(node, location: node.loc.begin.join(node.loc.end))
+          end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          def autocorrect(node)
+            lambda do |corrector|
+              if parentheses_at_the_end_of_multiline_call?(node)
+                corrector.replace(args_begin(node), ' \\')
+              else
+                corrector.replace(args_begin(node), ' ')
+              end
+              corrector.remove(node.loc.end)
+            end
+          end
+
+          def message(_node = nil)
+            'Omit parentheses for method calls with arguments.'
+          end
+
+          private
+
+          def super_call_without_arguments?(node)
+            node.super_type? && node.arguments.none?
+          end
+
+          def allowed_camel_case_method_call?(node)
+            node.camel_case_method? &&
+              (node.arguments.none? ||
+              cop_config['AllowParenthesesInCamelCaseMethod'])
+          end
+
+          def parentheses_at_the_end_of_multiline_call?(node)
+            node.multiline? &&
+              node.loc.begin.source_line
+                  .gsub(TRAILING_WHITESPACE_REGEX, '')
+                  .end_with?('(')
+          end
+
+          def legitimate_call_with_parentheses?(node)
+            call_in_literals?(node) ||
+              call_with_ambiguous_arguments?(node) ||
+              call_in_logical_operators?(node) ||
+              call_in_optional_arguments?(node) ||
+              allowed_multiline_call_with_parentheses?(node) ||
+              allowed_chained_call_with_parentheses?(node)
+          end
+
+          def call_in_literals?(node)
+            node.parent &&
+              (node.parent.pair_type? ||
+              node.parent.array_type? ||
+              node.parent.range_type? ||
+              splat?(node.parent) ||
+              ternary_if?(node.parent))
+          end
+
+          def call_in_logical_operators?(node)
+            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            parent &&
+              (logical_operator?(parent) ||
+              parent.send_type? &&
+              parent.arguments.any?(&method(:logical_operator?)))
+          end
+
+          def call_in_optional_arguments?(node)
+            node.parent &&
+              (node.parent.optarg_type? || node.parent.kwoptarg_type?)
+          end
+
+          def call_with_ambiguous_arguments?(node)
+            call_with_braced_block?(node) ||
+              call_as_argument_or_chain?(node) ||
+              hash_literal_in_arguments?(node) ||
+              node.descendants.any? do |n|
+                ambigious_literal?(n) || logical_operator?(n) ||
+                  call_with_braced_block?(n)
+              end
+          end
+
+          def call_with_braced_block?(node)
+            (node.send_type? || node.super_type?) &&
+              node.block_node && node.block_node.braces?
+          end
+
+          def call_as_argument_or_chain?(node)
+            node.parent &&
+              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
+              node.parent.csend_type? || node.parent.super_type?)
+          end
+
+          def hash_literal_in_arguments?(node)
+            node.arguments.any? do |n|
+              hash_literal?(n) ||
+                n.send_type? && node.descendants.any?(&method(:hash_literal?))
+            end
+          end
+
+          def allowed_multiline_call_with_parentheses?(node)
+            cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
+          end
+
+          def allowed_chained_call_with_parentheses?(node)
+            return false unless cop_config['AllowParenthesesInChaining']
+
+            previous = node.descendants.first
+            return false unless previous&.send_type?
+
+            previous.parenthesized? ||
+              allowed_chained_call_with_parentheses?(previous)
+          end
+
+          def ambigious_literal?(node)
+            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
+              unary_literal?(node)
+          end
+
+          def splat?(node)
+            node.splat_type? || node.kwsplat_type? || node.block_pass_type?
+          end
+
+          def ternary_if?(node)
+            node.if_type? && node.ternary?
+          end
+
+          def logical_operator?(node)
+            (node.and_type? || node.or_type?) && node.logical_operator?
+          end
+
+          def hash_literal?(node)
+            node.hash_type? && node.braces?
+          end
+
+          def regexp_slash_literal?(node)
+            node.regexp_type? && node.loc.begin.source == '/'
+          end
+
+          def unary_literal?(node)
+            node.numeric_type? && node.sign? ||
+              node.parent&.send_type? && node.parent&.unary_operation?
+          end
+
+          def assigned_before?(node, target)
+            node.assignment? &&
+              node.loc.operator.begin < target.loc.begin
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style require_parentheses
+        module RequireParentheses
+          def on_send(node)
+            return if ignored_method?(node.method_name)
+            return if matches_ignored_pattern?(node.method_name)
+            return if eligible_for_parentheses_omission?(node)
+            return unless node.arguments? && !node.parenthesized?
+
+            add_offense(node)
+          end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          def autocorrect(node)
+            lambda do |corrector|
+              corrector.replace(args_begin(node), '(')
+
+              corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
+            end
+          end
+
+          def message(_node = nil)
+            'Use parentheses for method calls with arguments.'
+          end
+
+          private
+
+          def eligible_for_parentheses_omission?(node)
+            node.operator_method? || node.setter_method? || ignored_macro?(node)
+          end
+
+          def included_macros_list
+            cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+          end
+
+          def ignored_macro?(node)
+            cop_config['IgnoreMacros'] &&
+              node.macro? &&
+              !included_macros_list.include?(node.method_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,11 +3,44 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks presence of parentheses in method calls containing
-      # parameters. By default, macro methods are ignored. Additional methods
-      # can be added to the `IgnoredMethods` list.
+      # This cop enforces the presence (default) or absence of parentheses in
+      # method calls containing parameters.
       #
-      # @example
+      # In the default style (require_parentheses), macro methods are ignored.
+      # Additional methods can be added to the `IgnoredMethods`
+      # or `IgnoredPatterns` list. These options are
+      # valid only in the default style. Macros can be included by
+      # either setting `IgnoreMacros` to false or adding specific macros to
+      # the `IncludedMacros` list.
+      #
+      # Precedence of options is all follows:
+      #
+      # 1. `IgnoredMethods`
+      # 2. `IgnoredPatterns`
+      # 3. `IncludedMacros`
+      #
+      # eg. If a method is listed in both
+      # `IncludedMacros` and `IgnoredMethods`, then the latter takes
+      # precedence (that is, the method is ignored).
+      #
+      # In the alternative style (omit_parentheses), there are three additional
+      # options.
+      #
+      # 1. `AllowParenthesesInChaining` is `false` by default. Setting it to
+      #    `true` allows the presence of parentheses in the last call during
+      #    method chaining.
+      #
+      # 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it
+      #     to `true` allows the presence of parentheses in multi-line method
+      #     calls.
+      #
+      # 3. `AllowParenthesesInCamelCaseMethod` is `false` by default. This
+      #     allows the presence of parentheses when calling a method whose name
+      #     begins with a capital letter and which has no arguments. Setting it
+      #     to `true` allows the presence of parentheses in such a method call
+      #     even with arguments.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
       #
       #   # bad
       #   array.delete e
@@ -26,64 +59,131 @@ module RuboCop
       #   # okay with `puts` listed in `IgnoredMethods`
       #   puts 'test'
       #
-      #   # IgnoreMacros: true (default)
+      #   # okay with `^assert` listed in `IgnoredPatterns`
+      #   assert_equal 'test', x
+      #
+      # @example EnforcedStyle: omit_parentheses
+      #
+      #   # bad
+      #   array.delete(e)
+      #
+      #   # good
+      #   array.delete e
+      #
+      #   # bad
+      #   foo.enforce(strict: true)
+      #
+      #   # good
+      #   foo.enforce strict: true
+      #
+      # @example IgnoreMacros: true (default)
       #
       #   # good
       #   class Foo
       #     bar :baz
       #   end
       #
-      #   # IgnoreMacros: false
+      # @example IgnoreMacros: false
       #
       #   # bad
       #   class Foo
       #     bar :baz
       #   end
+      #
+      # @example AllowParenthesesInMultilineCall: false (default)
+      #
+      #   # bad
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInMultilineCall: true
+      #
+      #   # good
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      # @example AllowParenthesesInChaining: false (default)
+      #
+      #   # bad
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInChaining: true
+      #
+      #   # good
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: false (default)
+      #
+      #   # bad
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
+      #
+      # @example AllowParenthesesInCamelCaseMethod: true
+      #
+      #   # good
+      #   Array(1)
+      #
+      #   # good
+      #   Array 1
       class MethodCallWithArgsParentheses < Cop
-        MSG = 'Use parentheses for method calls with arguments.'.freeze
-
-        def on_send(node)
-          return if ignored_method?(node)
-          return unless node.arguments? && !node.parenthesized?
-
-          add_offense(node)
-        end
-        alias on_super on_send
-        alias on_yield on_send
+        include ConfigurableEnforcedStyle
+        include IgnoredMethods
+        include IgnoredPattern
 
-        private
+        def initialize(*)
+          super
+          return unless style_configured?
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(args_begin(node), '(')
-            corrector.insert_after(args_end(node), ')')
+          case style
+          when :require_parentheses
+            extend RequireParentheses
+          when :omit_parentheses
+            extend OmitParentheses
           end
         end
 
-        def ignored_method?(node)
-          node.operator_method? || node.setter_method? ||
-            ignore_macros? && node.macro? ||
-            ignored_list.include?(node.method_name)
-        end
+        # @abstract Overridden in style modules
+        def autocorrect(_node); end
 
-        def ignored_list
-          cop_config['IgnoredMethods'].map(&:to_sym)
-        end
-
-        def ignore_macros?
-          cop_config['IgnoreMacros']
-        end
+        private
 
         def args_begin(node)
           loc = node.loc
           selector =
             node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-          selector.end.resize(1)
+
+          resize_by = args_parenthesized?(node) ? 2 : 1
+          selector.end.resize(resize_by)
         end
 
         def args_end(node)
           node.loc.expression.end
         end
+
+        def args_parenthesized?(node)
+          return false unless node.arguments.one?
+
+          first_node = node.arguments.first
+          first_node.begin_type? && first_node.parenthesized_call?
+        end
       end
     end
   end

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

@@ -12,21 +12,20 @@ module RuboCop
       #   # good
       #   object.some_method
       class MethodCallWithoutArgsParentheses < Cop
-        MSG = 'Do not use parentheses for method calls with ' \
-              'no arguments.'.freeze
+        include IgnoredMethods
 
-        ASGN_NODES = %i[lvasgn masgn] + SHORTHAND_ASGN_NODES
+        MSG = 'Do not use parentheses for method calls with ' \
+              'no arguments.'
 
         def on_send(node)
           return if ineligible_node?(node)
           return unless !node.arguments? && node.parenthesized?
+          return if ignored_method?(node.method_name)
           return if same_name_assignment?(node)
 
-          add_offense(node, location: :begin)
+          add_offense(node, location: node.loc.begin.join(node.loc.end))
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.remove(node.loc.begin)
@@ -34,29 +33,28 @@ module RuboCop
           end
         end
 
+        private
+
         def ineligible_node?(node)
-          node.camel_case_method? || node.implicit_call? || node.keyword_not?
+          node.camel_case_method? || node.implicit_call? || node.prefix_not?
         end
 
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|
-            if asgn_node.masgn_type?
-              next variable_in_mass_assignment?(node.method_name, asgn_node)
-            end
+            next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
 
             asgn_node.loc.name.source == node.method_name.to_s
           end
         end
 
         def any_assignment?(node)
-          node.each_ancestor(*ASGN_NODES).any? do |asgn_node|
+          node.each_ancestor(*AST::Node::ASSIGNMENTS).any? do |asgn_node|
             # `obj.method = value` parses as (send ... :method= ...), and will
             # not be returned as an `asgn_node` here, however,
             # `obj.method ||= value` parses as (or-asgn (send ...) ...)
             # which IS an `asgn_node`. Similarly, `obj.method += value` parses
             # as (op-asgn (send ...) ...), which is also an `asgn_node`.
-            if asgn_node.or_asgn_type? || asgn_node.and_asgn_type? ||
-               asgn_node.op_asgn_type?
+            if asgn_node.shorthand_asgn?
               asgn_node, _value = *asgn_node
               next if asgn_node.send_type?
             end
@@ -69,7 +67,7 @@ module RuboCop
           mlhs_node, _mrhs_node = *node
           var_nodes = *mlhs_node
 
-          var_nodes.map { |n| n.to_a.first }.include?(variable_name)
+          var_nodes.any? { |n| n.to_a.first == variable_name }
         end
       end
     end

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

@@ -13,7 +13,9 @@ module RuboCop
       #     b
       #   end.c
       class MethodCalledOnDoEndBlock < Cop
-        MSG = 'Avoid chaining a method call on a do...end block.'.freeze
+        include RangeHelp
+
+        MSG = 'Avoid chaining a method call on a do...end block.'
 
         def on_block(node)
           # If the method that is chained on the do...end block is itself a
@@ -29,7 +31,7 @@ module RuboCop
 
           receiver = node.receiver
 
-          return unless receiver && receiver.block_type? &&
+          return unless receiver&.block_type? &&
                         receiver.loc.end.is?('end')
 
           range = range_between(receiver.loc.end.begin_pos,
@@ -37,6 +39,7 @@ module RuboCop
 
           add_offense(nil, location: range)
         end
+        alias on_csend on_send
       end
     end
   end

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

@@ -3,14 +3,94 @@
 module RuboCop
   module Cop
     module Style
-      # This cops checks for parentheses around the arguments in method
+      # This cop checks for parentheses around the arguments in method
       # definitions. Both instance and class/singleton methods are checked.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # The `require_parentheses` style requires method definitions
+      #   # to always use parentheses
+      #
+      #   # bad
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyle: require_no_parentheses
+      #   # The `require_no_parentheses` style requires method definitions
+      #   # to never use parentheses
+      #
+      #   # bad
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyle: require_no_parentheses_except_multiline
+      #   # The `require_no_parentheses_except_multiline` style prefers no
+      #   # parentheses when method definition arguments fit on single line,
+      #   # but prefers parentheses when arguments span multiple lines.
+      #
+      #   # bad
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
       class MethodDefParentheses < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
-        MSG_PRESENT = 'Use def without parentheses.'.freeze
+        MSG_PRESENT = 'Use def without parentheses.'
         MSG_MISSING = 'Use def with parentheses when there are ' \
-                      'parameters.'.freeze
+                      'parameters.'
 
         def on_def(node)
           args = node.arguments
@@ -29,25 +109,34 @@ module RuboCop
         end
         alias on_defs on_def
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             if node.args_type?
               # offense is registered on args node when parentheses are unwanted
-              corrector.replace(node.loc.begin, ' ')
-              corrector.remove(node.loc.end)
+              correct_arguments(node, corrector)
             else
-              args_expr = node.arguments.source_range
-              args_with_space = range_with_surrounding_space(args_expr, :left)
-              just_space = range_between(args_with_space.begin_pos,
-                                         args_expr.begin_pos)
-              corrector.replace(just_space, '(')
-              corrector.insert_after(args_expr, ')')
+              correct_definition(node, corrector)
             end
           end
         end
 
+        private
+
+        def correct_arguments(arg_node, corrector)
+          corrector.replace(arg_node.loc.begin, ' ')
+          corrector.remove(arg_node.loc.end)
+        end
+
+        def correct_definition(def_node, corrector)
+          arguments_range = def_node.arguments.source_range
+          args_with_space = range_with_surrounding_space(range: arguments_range,
+                                                         side: :left)
+          leading_space = range_between(args_with_space.begin_pos,
+                                        arguments_range.begin_pos)
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(arguments_range, ')')
+        end
+
         def require_parentheses?(args)
           style == :require_parentheses ||
             (style == :require_no_parentheses_except_multiline &&