Class: RuboCop::Cop::Style::MethodCallWithArgsParentheses

Enforces the presence (default) or absence of parentheses in method calls containing arguments.

In the default style (require_parentheses), macro methods are allowed. Additional methods can be added to the ‘AllowedMethods` or `AllowedPatterns` 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 as follows:

1. ‘AllowedMethods`

2. ‘AllowedPatterns`

3. ‘IncludedMacros`

If a method is listed in both ‘IncludedMacros` and `AllowedMethods`, then the latter takes precedence (that is, the method is allowed).

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. 

NOTE: The style of ‘omit_parentheses` allows parentheses in cases where omitting them results in ambiguous or syntactically incorrect code.

Non-exhaustive list of examples:

• Parentheses are required allowed in method calls with arguments inside literals, logical operators, setting default values in position and keyword arguments, chaining and more.

• Parentheses are allowed in method calls with arguments inside operators to avoid ambiguity. triple-dot syntax introduced in Ruby 2.7 as omitting them starts an endless range.

• Parentheses are allowed when forwarding arguments with the triple-dot syntax introduced in Ruby 2.7 as omitting them starts an endless range.

• Parentheses are required in calls with arguments when inside an endless method definition introduced in Ruby 3.0.

• Ruby 3.1’s hash omission syntax allows parentheses if the method call is in conditionals and requires parentheses if the call is not the value-returning expression. See bugs.ruby-lang.org/issues/18396.

• Parentheses are required in anonymous arguments, keyword arguments and block passing in Ruby 3.2.

• Parentheses are required when the first argument is a beginless range or the last argument is an endless range.