class RuboCop::Cop::Style::MethodCallWithArgsParentheses

end
bar :baz
class Foo
# bad
# IgnoreMacros: false
end
bar :baz
class Foo
# good
# IgnoreMacros: true (default)
puts ‘test’
# okay with ‘puts` listed in `IgnoredMethods`
foo.bar = baz
# Setter methods don’t need parens
# good
foo == bar
# Operators don’t need parens
# good
array.delete(e)
# good
array.delete e
# bad
@example
can be added to the ‘IgnoredMethods` list.
parameters. By default, macro methods are ignored. Additional methods
This cop checks presence of parentheses in method calls containing

def args_begin(node) 

def args_begin(node)
  loc = node.loc
  selector =
    node.super_type? || node.yield_type? ? loc.keyword : loc.selector
  resize_by = args_parenthesized?(node) ? 2 : 1
  selector.end.resize(resize_by)
end

def args_end(node) 

def args_end(node)
  node.loc.expression.end
end

def args_parenthesized?(node) 

def args_parenthesized?(node)
  return false unless node.arguments.one?
  first_node = node.arguments.first
  first_node.begin_type? && first_node.parenthesized_call?
end

def autocorrect(node) 

def autocorrect(node)
  lambda do |corrector|
    corrector.replace(args_begin(node), '(')
    unless args_parenthesized?(node)
      corrector.insert_after(args_end(node), ')')
    end
  end
end

def ignore_macros? 

def ignore_macros?
  cop_config['IgnoreMacros']
end

def ignored_method?(node) 

def ignored_method?(node)
  node.operator_method? || node.setter_method? ||
    ignore_macros? && node.macro? ||
    super(node.method_name)
end

def on_send(node) 

def on_send(node)
  return if ignored_method?(node)
  return unless node.arguments? && !node.parenthesized?
  add_offense(node)
end