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, adding specific macros to the IncludedMacros list, or using IncludedMacroPatterns for pattern-based matching.

Precedence of options is as follows:

AllowedMethods
AllowedPatterns
IncludedMacros
IncludedMacroPatterns

If a method is listed in both IncludedMacros/IncludedMacroPatterns 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

AllowedMethods: [“puts”, “print”]


# good
puts "Hello world"
print "Hello world"
# still enforces parentheses on other methods
array.delete(e)

AllowedPatterns: [“^assert”]


# good
assert_equal 'test', x
assert_match(/foo/, bar)
# still enforces parentheses on other methods
array.delete(e)

IncludedMacroPatterns: [“^assert”, “^refute”]


# bad
assert_equal 'test', x
refute_nil value

# good
assert_equal('test', x)
refute_nil(value)

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`



244
245
246

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

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

Instance Method Details

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



248
249
250

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

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