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

Inherits:

Base

Object
Base
RuboCop::Cop::Style::MethodCallWithArgsParentheses

show all

Extended by:: AutoCorrector

Includes:: AllowedMethods, AllowedPattern, ConfigurableEnforcedStyle, OmitParentheses, RequireParentheses

Defined in:: lib/rubocop/cop/style/method_call_with_args_parentheses.rb,
lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb,
lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

Overview

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:

‘AllowedMethods`
‘AllowedPatterns`
‘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.

‘AllowParenthesesInChaining` is `false` by default. Setting it to `true` allows the presence of parentheses in the last call during method chaining.

‘AllowParenthesesInMultilineCall` is `false` by default. Setting it

to `true` allows the presence of parentheses in multi-line method
calls.

‘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.

Examples:

EnforcedStyle: require_parentheses (default)


# bad
array.delete e

# good
array.delete(e)

# good
# Operators don't need parens
foo == bar

# good
# Setter methods don't need parens
foo.bar = baz

# okay with `puts` listed in `AllowedMethods`
puts 'test'

# okay with `^assert` listed in `AllowedPatterns`
assert_equal 'test', x

EnforcedStyle: omit_parentheses


# bad
array.delete(e)

# good
array.delete e

# bad
action.enforce(strict: true)

# good
action.enforce strict: true

# good
# Parentheses are allowed for code that can be ambiguous without
# them.
action.enforce(condition) || other_condition

# good
# Parentheses are allowed for calls that won't produce valid Ruby
# without them.
yield path, File.basename(path)

# good
# Omitting the parentheses in Ruby 3.1 hash omission syntax can lead
# to ambiguous code. We allow them in conditionals and non-last
# expressions. See https://bugs.ruby-lang.org/issues/18396
if meets(criteria:, action:)
  safe_action(action) || dangerous_action(action)
end

IgnoreMacros: true (default)


# good
class Foo
  bar :baz
end

IgnoreMacros: false


# bad
class Foo
  bar :baz
end

AllowParenthesesInMultilineCall: false (default)


# bad
foo.enforce(
  strict: true
)

# good
foo.enforce \
  strict: true

AllowParenthesesInMultilineCall: true


# good
foo.enforce(
  strict: true
)

# good
foo.enforce \
  strict: true

AllowParenthesesInChaining: false (default)


# bad
foo().bar(1)

# good
foo().bar 1

AllowParenthesesInChaining: true


# good
foo().bar(1)

# good
foo().bar 1

AllowParenthesesInCamelCaseMethod: false (default)


# bad
Array(1)

# good
Array 1

AllowParenthesesInCamelCaseMethod: true


# good
Array(1)

# good
Array 1

AllowParenthesesInStringInterpolation: false (default)


# bad
"#{t('this.is.bad')}"

# good
"#{t 'this.is.better'}"

AllowParenthesesInStringInterpolation: true


# good
"#{t('this.is.good')}"

# good
"#{t 'this.is.also.good'}"

Defined Under Namespace

Modules: OmitParentheses, RequireParentheses

Constant Summary

Instance Attribute Summary

Attributes inherited from Base

#config, #processed_source

Class Method Summary collapse

.autocorrect_incompatible_with ⇒ Object

Instance Method Summary collapse

#on_send(node) ⇒ Object (also: #on_csend, #on_yield)

Methods included from AutoCorrector

support_autocorrect?

Methods included from ConfigurableEnforcedStyle

#alternative_style, #alternative_styles, #ambiguous_style_detected, #correct_style_detected, #detected_style, #detected_style=, #no_acceptable_style!, #no_acceptable_style?, #opposite_style_detected, #style, #style_configured?, #style_detected, #style_parameter_name, #supported_styles, #unexpected_style_detected

Methods inherited from Base

#active_support_extensions_enabled?, #add_global_offense, #add_offense, #always_autocorrect?, badge, #begin_investigation, #callbacks_needed, callbacks_needed, #config_to_allow_offenses, #config_to_allow_offenses=, #contextual_autocorrect?, #cop_config, cop_name, #cop_name, department, documentation_url, exclude_from_registry, #excluded_file?, #external_dependency_checksum, inherited, #initialize, #inspect, joining_forces, lint?, match?, #message, #offenses, #on_investigation_end, #on_new_investigation, #on_other_file, #parse, #parser_engine, #ready, #relevant_file?, requires_gem, #string_literals_frozen_by_default?, support_autocorrect?, support_multiple_source?, #target_gem_version, #target_rails_version, #target_ruby_version

Methods included from ExcludeLimit

#exclude_limit

Methods included from AutocorrectLogic

#autocorrect?, #autocorrect_enabled?, #autocorrect_requested?, #autocorrect_with_disable_uncorrectable?, #correctable?, #disable_uncorrectable?, #safe_autocorrect?

Methods included from IgnoredNode

#ignore_node, #ignored_node?, #part_of_ignored_node?

Methods included from Util

silence_warnings

Constructor Details

This class inherits a constructor from RuboCop::Cop::Base

Class Method Details

.autocorrect_incompatible_with ⇒ `Object`



215
216
217

# File 'lib/rubocop/cop/style/method_call_with_args_parentheses.rb', line 215

def self.autocorrect_incompatible_with
  [Style::NestedParenthesizedCalls, Style::RescueModifier]
end

Instance Method Details

#on_send(node) ⇒ `Object` Also known as: on_csend, on_yield



219
220
221

# File 'lib/rubocop/cop/style/method_call_with_args_parentheses.rb', line 219

def on_send(node)
  send(style, node) # call require_parentheses or omit_parentheses
end