class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses
Checks for unwanted parentheses in parameterless method calls.
This cop’s allowed methods can be customized with ‘AllowedMethods`. By default, there are no allowed methods.
NOTE: This cop allows the use of ‘it()` without arguments in blocks, as in `0.times { it() }`, following `Lint/ItWithoutArgumentsInBlock` cop.
@example
# bad object.some_method() # good object.some_method
@example AllowedMethods: [] (default)
# bad object.foo()
@example AllowedMethods: [foo]
# good object.foo()
Constants
- MSG
Public Instance Methods
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 37 def on_send(node) return unless !node.arguments? && node.parenthesized? return if ineligible_node?(node) return if default_argument?(node) return if allowed_method_name?(node.method_name) return if same_name_assignment?(node) return if parenthesized_it_method_in_block?(node) register_offense(node) end
rubocop:disable Metrics/CyclomaticComplexity
Also aliased as: on_csend
Private Instance Methods
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 67 def allowed_method_name?(name) allowed_method?(name) || matches_allowed_pattern?(name) end
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 97 def any_assignment?(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`. next if asgn_node.shorthand_asgn? && asgn_node.lhs.call_type? yield asgn_node end end
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 63 def default_argument?(node) node.parent&.optarg_type? end
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 59 def ineligible_node?(node) node.camel_case_method? || node.implicit_call? || node.prefix_not? end
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 114 def offense_range(node) node.loc.begin.join(node.loc.end) end
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 89 def parenthesized_it_method_in_block?(node) return false unless node.method?(:it) return false unless (block_node = node.each_ancestor(:block).first) return false unless block_node.arguments.empty_and_without_delimiters? !node.receiver && node.arguments.empty? && !node.block_literal? end
Respects ‘Lint/ItWithoutArgumentsInBlock` cop and the following Ruby 3.3’s warning:
$ ruby -e ‘0.times { begin; it; end }’ -e:1: warning: ‘it` calls without arguments will refer to the first block param in Ruby 3.4; use it() or self.it
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 52 def register_offense(node) add_offense(offense_range(node)) do |corrector| corrector.remove(node.loc.begin) corrector.remove(node.loc.end) end end
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 71 def same_name_assignment?(node) return false if node.receiver any_assignment?(node) do |asgn_node| if asgn_node.masgn_type? variable_in_mass_assignment?(node.method_name, asgn_node) else asgn_node.loc.name.source == node.method_name.to_s end end end
Source
# File lib/rubocop/cop/style/method_call_without_args_parentheses.rb, line 110 def variable_in_mass_assignment?(variable_name, node) node.assignments.reject(&:send_type?).any? { |n| n.name == variable_name } end