class Parser::AST::Processor

def on_argument(node)
  arg_name, value_node = *node
  if !value_node.nil?
    node.updated(nil, [
      arg_name, process(value_node)
    ])
  else
    node
  end
end

def on_casgn(node)
  scope_node, name, value_node = *node
  if !value_node.nil?
    node.updated(nil, [
      process(scope_node), name, process(value_node)
    ])
  else
    node.updated(nil, [
      process(scope_node), name
    ])
  end
end

def on_const(node)
  scope_node, name = *node
  node.updated(nil, [
    process(scope_node), name
  ])
end

def on_def(node)
  name, args_node, body_node = *node
  node.updated(nil, [
    name,
    process(args_node), process(body_node)
  ])
end

def on_defs(node)
  definee_node, name, args_node, body_node = *node
  node.updated(nil, [
    process(definee_node), name,
    process(args_node), process(body_node)
  ])
end

def on_empty_else(node)
  node
end

def on_numblock(node)
  method_call, max_numparam, body = *node
  node.updated(nil, [
    process(method_call), max_numparam, process(body)
  ])
end

def on_op_asgn(node)
  var_node, method_name, value_node = *node
  node.updated(nil, [
    process(var_node), method_name, process(value_node)
  ])
end

def on_procarg0(node)
  if node.children[0].is_a?(Symbol)
    # This branch gets executed when the builder
    # is not configured to emit and 'arg' inside 'procarg0', i.e. when
    #   Parser::Builders::Default.emit_arg_inside_procarg0
    # is set to false.
    #
    # If this flag is set to true this branch is unreachable.
    # s(:procarg0, :a)
    on_argument(node)
  else
    # s(:procarg0, s(:arg, :a), s(:arg, :b))
    process_regular_node(node)
  end
end

def on_send(node)
  receiver_node, method_name, *arg_nodes = *node
  receiver_node = process(receiver_node) if receiver_node
  node.updated(nil, [
    receiver_node, method_name, *process_all(arg_nodes)
  ])
end

def on_var(node)
  node
end

def on_vasgn(node)
  name, value_node = *node
  if !value_node.nil?
    node.updated(nil, [
      name, process(value_node)
    ])
  else
    node
  end
end

def process_argument_node(node)
  on_argument(node)
end

def process_argument_node(node)
  warn 'Parser::AST::Processor#process_argument_node is deprecated as a' \
    ' public API and will be removed. Please use ' \
    'Parser::AST::Processor#on_argument instead.'
  on_argument(node)
end

def process_regular_node(node)
  node.updated(nil, process_all(node))
end

def process_var_asgn_node(node)
  on_vasgn(node)
end

def process_var_asgn_node(node)
  warn 'Parser::AST::Processor#process_var_asgn_node is deprecated as a' \
    ' public API and will be removed. Please use ' \
    'Parser::AST::Processor#on_vasgn instead.'
  on_vasgn(node)
end

def process_variable_node(node)
  on_var(node)
end

def process_variable_node(node)
  warn 'Parser::AST::Processor#process_variable_node is deprecated as a' \
    ' public API and will be removed. Please use ' \
    'Parser::AST::Processor#on_var instead.'
  on_var(node)
end