class RuboCop::Cop::Style::StabbyLambdaParentheses

->a,b,c { a + b + c}
# good
->(a,b,c) { a + b + c }
# bad
@example EnforcedStyle: require_no_parentheses
->(a,b,c) { a + b + c}
# good
->a,b,c { a + b + c }
# bad
@example EnforcedStyle: require_parentheses (default)
There are two different styles. Defaults to ‘require_parentheses`.
Check for parentheses around stabby lambda arguments.

def message(_node) 

def message(_node)
  style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
end

def missing_parentheses?(node) 

def missing_parentheses?(node)
  style == :require_parentheses && !parentheses?(node)
end

def missing_parentheses_corrector(corrector, node) 

def missing_parentheses_corrector(corrector, node)
  corrector.wrap(node, '(', ')')
end

def on_send(node) 

def on_send(node)
  return unless stabby_lambda_with_args?(node)
  return unless redundant_parentheses?(node) || missing_parentheses?(node)
  arguments = node.block_node.arguments
  add_offense(arguments) do |corrector|
    case style
    when :require_parentheses
      missing_parentheses_corrector(corrector, arguments)
    when :require_no_parentheses
      unwanted_parentheses_corrector(corrector, arguments)
    end
  end
end

def parentheses?(node) 

def parentheses?(node)
  node.block_node.arguments.loc.begin
end

def redundant_parentheses?(node) 

def redundant_parentheses?(node)
  style == :require_no_parentheses && parentheses?(node)
end

def stabby_lambda_with_args?(node) 

def stabby_lambda_with_args?(node)
  node.lambda_literal? && node.block_node.arguments?
end

def unwanted_parentheses_corrector(corrector, node) 

def unwanted_parentheses_corrector(corrector, node)
  args_loc = node.loc
  corrector.replace(args_loc.begin, '')
  corrector.remove(args_loc.end)
end