modules/configuration/configuration.module

<?php
// $Id: $

/**
 * @file
 * Provide a unified method for defining site configurations abstracted from their data format.
 * Various data formats should be supported via a plugin architecture such as XML, YAML, JSON, PHP
 */

/**
 * The first execution phase: Apply the base map to $context
 */
define('CONFIGURATION_INITIALIZE', 1);

/**
 * The second execution phase: Apply the base map to $context
 */
define('CONFIGURATION_DEFAULT_MAP', 2);

/**
 * The third execution phase: Enable all modules needed for the configuration
 */
define('CONFIGURATION_ENABLE_MODULES', 3);

/**
 * The fourth execution phase: Apply all modules configuration maps
 */
define('CONFIGURATION_MODULE_MAPS', 4);

/**
 * The fifth execution phase: Execute the built up actions, one action per execution pass.
 */
define('CONFIGURATION_EXECUTE_ACTIONS', 5);

/**
 * The six execution phase: Disable any modules marked for disabling
 */
define('CONFIGURATION_DISABLE_MODULES', 6);

/**
 * The seventh and last execution phase: Any needed cleanup operations
 */
define('CONFIGURATION_FINALIZE', 7);

/**
 * An execution phase to mark the success and completion of the configuration
 */
define('CONFIGURATION_SUCCESS', -1);

/**
 * An execution phase to mark an error in the execution somewhere
 */
define('CONFIGURATION_ERROR', 0);

/**
 * The key that signals an attribute in the end-result parsed data
 */
define('CONFIGURATION_ATTRIBUTE_KEY', '$');

/**
 * Implementation of hook_perm()
 */
function configuration_perm() {
  return array('execute configurations');
}

/**
 * Execute a configuration diven a data object of actions. The supplied
 * data should be a php array in the correct format.
 * 
 * Here is an example configuration to setup two blocks:
 * 
 * array(
 *   array(
 *     tag => block
 *     config => array(
 *       description => My Custom Block
 *       region => right
 *       weight => -5
 *     )
 *   )
 *   array(
 *     tag => block
 *     config => array(
 *       id => locale-0
 *       region => left
 *       weight => 5
 *     )
 *   )
 * )
 * 
 * @param $data
 *  The dataset containing the configuration to execute
 * @param $mode
 *  A string that will form a callback function used to dictate
 *  execution of the configuration. Two default modes are:
 *  - batch: Run the configuration on a batch/progress bar page
 *  - xmlrpc: Run the configuration through services without a 
 *            break in the pages php execution
 * 
 *  The job of the callback function is to ensure that data
 *  set in the configuration_set_data static cache is maintained
 *  through any possible page re-loads or however the execution
 *  is processed so that each pass of configuration_execute_pass
 *  has the right data available to it.
 * @return
 *  TRUE or FALSE for successful execution. The exact error in case
 *  of an unsuccessful run can be retrieved with configuration_get_error()
 */
function configuration_execute($data, $mode = 'batch', $current_id = null) {
  $args = func_get_args();
  array_splice($args, 0, 3);

  $function = 'configuration_execute_'. $mode;

  if (!function_exists($function)) {
    return FALSE;
  }

  // Create and set a unique id for this execution
  if (!$current_id) {
    $current_id = md5(mt_rand());
  }

  configuration_set_current_id($current_id);

  // Set the current data so it can be used with this execution
  configuration_set_data('data', $data);
  
  // Set to the first phase to get things started
  configuration_set_data('phase', CONFIGURATION_INTIALIZE);

  return call_user_func_array($function, $args);
}

/**
 * Run through a pass of the configuration process
 * 
 * @return
 *  Return the current phase
 */
function configuration_run_pass() {
  $phases = array(CONFIGURATION_INTIALIZE, CONFIGURATION_DEFAULT_MAP, CONFIGURATION_ENABLE_MODULES, CONFIGURATION_MODULE_MAPS, CONFIGURATION_EXECUTE_ACTIONS, CONFIGURATION_DISABLE_MODULES, CONFIGURATION_FINALIZE);

  $phase =& configuration_get_data('phase');
  $context =& configuration_get_data('context');
  $data =& configuration_get_data('data');
  
  // The context object is required for every phase except the first
  // Also, the original data object should always be a reference to the
  // data in the context object which we can't guarantee unless we do it
  // ourselves here.
  if (is_object($context)) {
    $data = &$context->item;
  }
  else if ($phase > CONFIGURATION_INTIALIZE) {
    configuration_set_error('no_context');
    $phase = CONFIGURATION_ERROR;
  }
  
  // Ensure our phase is valid
  if (!in_array($phase, $phases)) {
    configuration_set_error('invalid_phase', array('phase' => $phase));
  }

  // Make sure necessary include files are loaded
  configuration_load_includes();

  switch($phase) {
    // TODO Decide if maybe we should run the first few phases all at once
    case CONFIGURATION_INTIALIZE:
      configuration_initiate();
      $phase++;
    break;
    case CONFIGURATION_DEFAULT_MAP:
      // First apply the base configuration map. This primary purpose
      // of this map is to set appropriate attributes in the context
      // object, make it look a bit nicer, and build the module list
      configuration_apply_map($context, configuration_default_map());

      if (!configuration_get_error()) {
        $phase++;
      }
    break;
    case CONFIGURATION_ENABLE_MODULES:
      // Enable all modules set in the configuration
      $modules =& configuration_get_data('enable modules');
      if (!empty($modules)) {
        configuration_enable_modules($modules);
      }

      if (!configuration_get_error()) {
        $phase++;
      }
    break;
    case CONFIGURATION_MODULE_MAPS:
      // Apply all module configuration maps to the object to prepare
      // the data, apply some basic validations, and setup data needed
      // for the next configuration phases
      configuration_apply_maps($context);

      if (!configuration_get_error()) {
        $phase++;
      }
    break;
    case CONFIGURATION_EXECUTE_ACTIONS:
      // Go through the built list of actions and build/run them one at a time
      configuration_process_actions();
      
      $left = count(configuration_get_data('actions'));
      if ($phase != CONFIGURATION_ERROR && !$left) {
        $phase++;
      }
    break;
    case CONFIGURATION_DISABLE_MODULES:
      // Disable modules
      $modules =& configuration_get_data('disable modules');
      if (!empty($modules)) {
        configuration_disable_modules($modules);
      }
      
      if (!configuration_get_error()) {
        $phase++;
      }
    break;
    case CONFIGURATION_FINALIZE:
      // The configuration succeed so do any necessary cleanup
      configuration_finalize();
      $phases++;
    break;
    case CONFIGURATION_SUCCESS:
      // We are done. Nothing to do here.
    break;
    case CONFIGURATION_ERROR:
    default:
      // TODO Error handling
    break;
  }
  
  // Any data can be retreived through configuration_get_data, but this can be
  // a quick way of determining if there was an error
  return $phase;
}

/**
 * The "batch" method of executing a configuration
 * 
 * The job of this method is to save and set the configuration data
 * upon the start of each batch operation while passing it through
 * the batch sandbox
 */
function configuration_execute_batch() {
  $batch = array(
    'init_message' => t('Running action @current out of @total', array('@current' => 1, '@total' => 7)),
    'progress_message' => t('Running action @current out of @total.'),
    'operations' => array(),
  );

  for($i=1;$i<=7;$i++) {
    $batch['operations'][] = array('_configuration_execute_batch', array());
  }

  batch_set($batch);

  // Get the current batch so we can add the current configuration data
  $batch =& batch_get();
  $batch['sets'][0]['results']['configuration_data'] = configuration_get_data(null, true);

  batch_process();
}

/**
 * Batch callback function for batch execution
 */
function _configuration_execute_batch(&$batch_context) {
  // Set the configuration data
  configuration_set_data(null, null, $batch_context['results']['configuration_data']);
  
  // Bail on an error
  if (configuration_get_error()) {
    configuration_debug_batch(configuration_set_error());
  }

  // Start a timer. Since we want each action to be its own http request, we need
  // to ensure the batch api will decide to do it like that by making each action
  // take at least a second to execute
  timer_start('configuration_action');

  // Run the current pass
  $phase = configuration_run_pass();
  
  // Deal with custom stuff for the error and action phases
  if ($phase == CONFIGURATION_EXECUTE_ACTIONS) {
    $done = configuration_get_data('actions done');
    $left = configuration_get_data('actions');
    $done = count($done);
    $left = count($left);
    
    if ($done != $left) {
      // Set the progress and message of the actions
      $batch_context['finished'] = $done / ($done + $left);
      $batch_context['message'] = t('@current out of @total', array('@current' => $done, '@total' => $done + $left));

      // Sleep till 1000 (a second) if needed so we know we'll get a new page load
      if (timer_read('configuration_action') < 1000) {
        //@usleep(1000 - timer_read('configuration_action'));
      }
    }
  }
  
  // Make sure batch is updated with the updated configuration data store
  $batch_context['results']['configuration_data'] = configuration_set_data();
}

/**
 * Print debug data during a batch operation
 */
function configuration_debug_batch($var = null) {
  $var = print_r($var, true);
  $var = str_replace(" ", '&nbsp;', $var);
  $var = str_replace("\n", "<br />", $var);
  print drupal_to_js(array('status' => 0, 'data' => $var));
  exit;
}

/**
 * Move through the actions list processing one per call
 */
function configuration_process_actions() {
  $actions =& configuration_get_data('actions');
  $done =& configuration_get_data('actions done');

  if (empty($actions) || !isset($actions[0])) {
    return true;
  }

  // Get the next action
  $action = $actions[0];
  array_shift($actions);
  
  // If the action here is not set, call the callback to set them
  if (!isset($action[0]) && ($callback = $action[1]->action_callback) && function_exists($callback)) {
    $value = $callback($action[1]->item, $action[1]);

    if (!configuration_get_error() && !isset($value)) {
      $done[] = $action;
      return true;
    }

    if (is_scalar($value)) {
      $value = array($value);
    }
    
    // Insert the action(s) here and move out so the next calls can handle them
    $context = &$action[1];
    for($i=count($value)-1;isset($value[$i]);$i--) {
      $new = array($value[$i], &$context);
      array_unshift($actions, $new);
    }

    $done[] = $action;
    return true;
  }
  else if (!isset($action[0])){
    configuration_set_error('missing action', array('!context' => $action[1]));
  }

  // Process this action
  if (!configuration_get_error() && $action[0]) {
    configuration_process_action($action);
  }

  // Mark this action as complete if no errors
  if (!configuration_get_error()) {
    $done[] = $action;
  }
  else {
    // Put the action back on if there was an error. Maybe the error
    // can be corrected and tried again
    array_unshift($actions, $action);
  }
}

/**
 * Execute a single action
 */
function configuration_process_action($action) {
  // Get the module list of actions and identifiers
  $actions =& module_invoke_all('configuration_actions');
  $identifiers =& configuration_get_data('identifiers');

  $action_id = $action[0];
  $action_info = $actions[$action_id];
  $action_context = &$action[1];

  if (!isset($action_info)) {
    configuration_set_error('invalid action id', array('!action' => $action_id));
    return false;
  }

  // Replace identifiers and tokens in the action data
  configuration_replace_tokens($action_context, $identifiers);
  
  // Unlikely, but if there is an error replacing tokens
  if (configuration_get_error()) {
    return false;
  }

  // With proper data and values replaced, apply the actions build map. This is a great
  // place to do any validation as well (using a #validate callback property or directly)
  // TODO Implement #validate property...
  if ($action_info['#build map']) {
    configuration_apply_map($action_context, $action_info['#build map']);
  }

  if (configuration_get_error()) {
    configuration_set_error('action build map', array('!action' => $action_id));
  }

  // Build the execute $args array. Starting with the actual form data
  //if ($action_context->build_data) {
  if ($action_info['#build data'] && ($matches = configuration_fetch($action_info['#build data'], $action_context))) {
    $action_data = $matches[0]->item;
  }
  else {
    $action_data = $action_context->item;
  }

  // Then the form state
  if ($action_context->form_state) {
    $action_state = &$action_context->form_state;
    $action_state['values'] = &$action_data;
  }
  else {
    $action_state = array(
      'storage' => null,
      'submitted' => false,
      'values' => &$action_data
    );
  }
  // Then the params
  for($i=0;isset($action_info['#parameters'][$i]);$i++) {
    $matches = configuration_fetch($action_info['#parameters'][$i], $action_context);
    // Ensure that the parameter is at least set
    $params[$i] = null;
    if (isset($matches[0])) {
      $params[$i] = $matches[0]->item;
    }
  }

  // Drupal Execute
  configuration_drupal_execute($action_id, $action_state, $params);

  // Store any form errors
  if ($form_errors = form_set_error()) {
    configuration_set_error('form error', $form_errors);
  }
  // Run an on-success map and save any identifiers
  else {
    if ($action_info['#success map']) {
      configuration_apply_map($action_context, $action_info['#success map']);
    }
    // TODO Replace identifiers before running action
    if (!empty($action_info['#identifiers'])) {
      for($i=0;isset($action_info['#identifiers'][$i]);$i++) {
        $matches = configuration_fetch($action_info['#identifiers'][$i], $action_context);

        // TODO Should we set an error if count($matches) > 1 ?
        if (!empty($matches)) {
          $action_context->identifiers[$i] = $matches[0]->item;
          
          // Make an id=>identifier map for easier access
          if ($action_context->id) {
            $identifiers[$action_context->id] = &$action_context->identifiers[$i];
          }
        }
      }
    }
  }

  // Cleanup items
  unset($action_context->build_data, $action_context->form_state);
  
  if ($action_info['#cleanup map']) {
    configuration_apply_map($action_context, $action_info['#cleanup map']);
  }
}

/**
 * Apply all module configuration maps to the data while
 * building the action queue at the same time
 * 
 * @param $context
 *  The context array needing the config maps applied to
 * @return
 *  An array of actions referencing points in the $context object for
 *  later use in action execution
 */
function configuration_apply_maps(&$context) {
  // Get all the module maps and apply each one to the context object
  foreach(module_implements('configuration_maps') as $module) {
    $map = module_invoke($module, 'configuration_maps');
    configuration_apply_map($context, $map);
  }
}

/**
 * Apply an individual configuration map to the data set object
 * 
 * @param $context
 *  The context array for which to apply the map
 * @param $map
 *  The configuration map to apply to the context array
 * @return
 *  An array of referenced actions that resulted from this configuration map
 */
function configuration_apply_map(&$context, $map) {
  foreach($map as $path => &$config) {
    // TODO Make $path available in sub-functions for error reporting
    // Get the matches for this path
    $matches = configuration_fetch($path, $context, TRUE);

    while(!empty($matches)) {
      // Get and drop off the first match from the matches array
      $match = &$matches[0];
      array_shift($matches);
      
      // If this match is null (was unset somewhere) skip it
      if (!isset($match)) {
        continue;
      }

      // Setup a list of properties to process in the right order
      $properties = array_keys(array_intersect_key(configuration_map_properties(), $config));
  
      // Loop through the properties list processing one at a time
      foreach($properties as $property) {
        $value = $config[$property];

        // Process this property
        configuration_context_process_property($property, $value, $match, $config);

        // Unset this property as we are done with it
        unset($properties[$property]);
      }
    }
  }
}

/**
 * The default configuration map that is applied to all configuration
 * context objects. For the time being all it does is make it easier
 * to visualize the incoming configuration data and set up the module
 * list.
 * 
 * The original format of the incoming data is like: array(
 *   array( type => block, config => array( // config data ) )
 *   array( type => block, config => array( // config data ) )
 *   array( type => menu, config => array( // config data ) )
 * )
 * 
 * Applying a config path against an object like that would look like:
 * /*[type=block]/config
 * 
 * When in realitiy all that should be needed is:
 * /block
 * 
 * This is accomplished here by moving the config data a level above it
 * and getting rid of the tag key from the data object completely. The
 * tag key is set in the context object and is made to act as a secondary
 * array key (the original is just an indexed number).
 * 
 * The new configuration looks like: array(
 *   array( array( // config data ) ) // secondary_key=block
 *   array( array( // config data ) ) // secondary_key=block
 *   array( array( // config data ) ) // secondary_key=menu
 * )
 */
function configuration_default_map() {
  return array(
    '//*' => array('#value callback' => 'configuration_find_attributes'), // Convert tags starting with a # to attributes
    '/*/tag' => array('#required' => true, '#context key' => true),
    '/*/config' => array('#move' => '..'),
    '/module' => array('#array' => true), // TODO This is temporary since the next item can't catch these matches after the #alias yet
    '/modules' => array('#alias' => array('module'), '#array' => true),
    '/modules/*' => array('#enable module' => true)
  );
}

/**
 * Return a list of supported config properties in the order they
 * should be processed with their descriptions
 * 
 * TODO Remove descriptions here as they could just be in documentation somewhere.
 * TODO Allow modules to specify custom properties as well that would get sent to custom callbacks. Or add a #utility type property that handles a variety of functionality including module custom functionality. Such as a 'split' utitlity or in block modules case a custom function to split a module ID (block-3) into module=block and delta=3.
 */
function configuration_map_properties() {
  return array(
    '#include' => t('Include/require a file during the build process.'),
    '#alias' => t('Allow a tag to have aliases for better readability.'),
    '#default callback' => t('Set the default value if the tag is missing via a callback'),
    '#default php' => t('Set the default value if the tag is missing via a php snippet'),
    '#default path' => t('Set the default value if the tag is missing via a path to another item.'),
    '#default value' => t('Set the default value if the tag is missing.'),
    '#default' => t('Same as #default value'),
    '#create' => t('Create the tag under this tag if it does not exist. Either the name of the tag can be set or both the name and the value like: array( name => value )'),
    '#key' => t('The name of the tag will change to this when processed.'),
    '#key callback' => t('The tag will change when processed to the result of the callback'),
    '#key path' => t('The tag will change when processed to the value of the tag at the specified path in the data object. In case the path does not exist a default value can be specified by setting an array like: array( path => default )'),
    '#key php' => t('The tag will change when processed to the value of the evaluted php.'),
    '#array' => t('Mark that this data must be an array and make it so if it is not.'),
    '#assoc' => t('Mark that this data must be an associative array. We cannot make it one if it is not.'),
    '#move' => t('Move the tag to a different location specified by a path here. The end of the path will replace the current key.'),
    '#copy' => t('Copy this tag to another location specified by a path here.'),
    '#required' => t('Specify that this tag is required and must be specified.'),
    '#context key' => t('Act as a secondary_key for that data object and will be matched against config paths.'),
    '#value alias' => t('A key=>list array that determines possible aliases of certain values'),
    '#value callback' => t('Apply a callback on a value. The returned value will become the new value.'),
    '#value php' => t('Run a php snippet on the value here. The returned value will become the new value.'),
    '#value path' => t('Set the value of this item to the item specified with the path.'),
    '#value' => t('Set the value to what is specified here.'),
    '#id callback' => t('Run a callback that returns an identifier for the action.'),
    '#id php' => t('Evaluate php that returns an identifier for the action.'),
    '#options' => t('An array of possible values for the tag. It must be one of them.'),
    '#options callback' => t('An array of possible values for the tag as returned from the callback.'),
    '#build callback' => t('The return of this callback will be used as the input data for the execution and will not replace the data in the $context object.'),
    '#build php' => t('Use a php snippet to get the build data instead of the callback.'),
    '#action' => t('Specify an action to be called on the corresponding data. This will be saved and run at the end of the execution process.'),
    '#action callback' => t('A callback that will specify the action to be run here. This callback is run after previous actions are executed.'),
    '#attribute' => t('A boolean value specifying wether this tag/value pair is an attribute. Child tags are not allowed with attributes. Attributes stay in the context object, but not in the actual data set.'),
    '#enable module' => t('Add the module here to the enable modules list.'),
    '#disable module' => t('Add the module here to the disable modules list.'),
    '#delete' => t('Remove the key=>value from the object completely.')
  );
}

/**
 * Process a single mapping config property. Various properties will mark static data
 * that will be processed later on in the configuration phases.
 * 
 * @param $property
 *  The property needing processed
 * @param $value
 *  The value of the property
 * @param $context
 *  The context area of the data to process with this property
 * @param $config
 *  The config this property=>value pair is a part of
 */
function configuration_context_process_property($property, $value, &$context, &$config = array()) {
  $empty = $context->empty;

  // This is a list of properties that can take an empty match
  $empty_properties = array('#alias', '#required', '#create', '#default', '#default callback', '#default php', '#default path', '#default value');
  
  // This is a list of properties that do not modify the context object
  // which will save any integrity checks later on
  $no_modify_propertiers = array('#include', '#action', '#action callback', '#required', '#options', '#options callback');
  
  
  // If this is an empty context and not in the empty property list, return immediately
  if ($empty && !in_array($property, $empty_properties)) {
    return;
  }

  switch ($property) {
    case '#include':
      $file = './'. $value;
      if (!is_file($file)) {
        configuration_set_error('pre-validate: include', array('!file' => $file));
      }
      else {
        @require_once $file;
        $context->include = $file;
      }
    break;
    case '#alias':
      // TODO Figure out how to deal with the $matches array syncing with new matches here
      if ($empty) {
        if (is_scalar($value)) {
          $value = array($value);
        }
        
        foreach($value as $alias) {
          // Find the alias, if it exists rename it
          if (array_key_exists($alias, $context->parent->item)) {
            // Find the alias context
            for($i=0;isset($context->parent->children[$i]);$i++) {
              $change = &$context->parent->children[$i];
              if ($change->key == $alias) {
                configuration_context_process_property('#key', $context->key, $change, $config);
                break(2);
              }
            }
          }
        }
      }
      
      // Deal with secondary keys here. No need to check if it already exists
      // since they can exist multiple times
      for($i=0;isset($context->parent->children[$i]);$i++) {
        $check=&$context->parent->children[$i];
        if (($pos = in_array($check->secondary_key, $value)) !== false) {
          $check->secondary_key = $context->secondary_key;
        }
      }
    break;
    case '#default callback':
      if ($empty) {
        if (is_array($value)) {
          $args = reset($value);
          $value = key($value);
        }
        if (function_exists($value)) {
          if (isset($args)) {
            $context->parent->item[$context->key] = call_user_func_array($value, $args);
          }
          else {
            $context->parent->item[$context->key] = $value($context);
          }
          $context->empty = false;
        }
      }
    break;
    case '#default php':
      if ($empty) {
        // Make sure it is set and then get the default and reset it to that
        $context->parent->item[$context->key] = null;
        $php = $value;
        $value = &$context->parent->item[$context->key];
        $new = eval($php);
        if (isset($new)) {
          $context->parent->item[$context->key] = $new;
        }
        $context->empty = false;
      }
    break;
    case '#default path':
      if ($empty && ($matches = configuration_fetch($value, $context)) && count($matches) == 1) {
        $context->parent->item[$context->key] = $matches[0]->item;
        $context->empty = false;
      }
    break;
    case '#default':
    case '#default value':
    case '#create':
      if ($empty) {
        // TODO Think about converting all other context keys to ->_ like ->_parent ->_item
        if ($context->_attribute) {
          $context->item = $value;
        }
        else {
          $context->parent->item[$context->key] = $value;
          $context->item = &$context->parent->item[$context->key];
        }
        $context->empty = false;
      }
    break;
    case '#key callback':
      if (function_exists($value)) {
        $value = $value($context->item);
      }
      else {
        configuration_set_error(t('An invalid callback was specified: !callback', array('!callback' => $value)));
        break;
      }
    case '#key path':
      if ($property == '#key path') {
        if (is_array($value)) {
          $path = key($value);
          $default = current($value);
        }
        else {
          $path = $value;
        }
        $match = configuration_fetch($path, $context);
        
        if (count($match) == 1 && is_scalar($match[0]->item)) {
          $value = $match[0]->item;
        }
        else if ($config['#key default']) {
          $value = $config['#key default'];
        }
        else {
          break;
        }
      }
    case '#key php':
      if ($property == '#key php') {
        $value = eval($value);
      }
    break;
    case '#key':
      if (array_key_exists($value, $context->parent->item)) {
        // Key exists already
        // TODO Is it a problem that the key exists already? Quite possibly....
        break;
      }

      $key = $context->key;
      $context->parent->item[$value] = &$context->item;

      // We need to keep our current context object. check_context should fix the trace paths below
      $context->key = $value;

      // A plain unset is sufficient even with indexed arrays because check_context will pick it up and fix
      unset($context->parent->item[$key]);
    break;
    case '#array':
      // TODO Figure out how to deal with associative vs indexed arrays
      if (!is_array($context->item) || !array_key_exists(0, $context->item)) {
        if (is_null($context->item) || (is_array($context->item && empty($context->item)))) {
          $context->item = array();
        }
        else {
          $context->item = array($context->item);
        }
      }
    break;
    case '#assoc':
      if (!is_array($value) || array_key_exists(0, $context->item)) {
        configuration_set_error('assoc array');
      }
    break;
    // TODO Test both copy and move
    case '#copy':
      $destinations = configuration_fetch($value, $context);
      
      foreach($destinations as &$dest) {
        // TODO We are making it impossible to overwrite an existing item. Maybe we should make it possible? This applies to #move too
        if ($dest->empty) {
          $dest->item = $context->item;
        }
      }
    break;
    case '#move':
      // TODO Moving/Copying to the same array level as the current item can cause problems with the current matches set. Maybe make it impossible to do so or think of a solution.
      $dest = configuration_fetch($value, $context);

      if (count($dest) == 1 && $dest = &$dest[0]) {
        $parent = &$context->parent;
        $key = $context->key;

        // Move the necessary dest info over here
        foreach(array_diff(array_keys((array) $dest), array('children', 'item')) as $key) {
          // TODO Is there room to do better memory cleanup here or does it not matter?
          $context->$key = &$dest->$key;
        }

        // Make sure the old child pointer points to the new context
        for($i=0;isset($context->parent->children[$i]);$i++) {
          $check = &$context->parent->children[$i];
          if ($check === $dest) {
            $context->parent->children[$i] = &$context;
            break;
          }
        }

        // Make sure the moved data exists in the right place of the original array
        $context->parent->item[$context->key] = &$context->item;

        // Remove the item here. check_context will make sure contexts are removed
        // We can't remove if we moved to this items parent
        // TODO Make it work so you can move two parents up
        if ($parent !== $dest) {
          unset($parent->item[$key]);
        }
        
        // Fix all the children trace paths
        configuration_fix_context_trace($context);
      }
    case '#required':
      if ($context->empty) {
        $path = implode('/', array_merge($context->trace, array($context->key)));
        configuration_set_error('pre-validate: required', array('!tag' => $path));
      }
      else {
        $context->required = true;
      }
    break;
    case '#context key':
      if (is_scalar($context->item)) {
        $context->parent->secondary_key = $context->item;
      }
    break;
    case '#attribute':
      if (!is_scalar($context->item)) {
        $path = implode('/', $context->trace);
        configuration_set_error('pre-validate: attribute', array('!tag' => $path));
      }
      else {
        if ($context->key[0] == CONFIGURATION_ATTRIBUTE_KEY) {
          $key = substr($context->key, 1);
        }
        else {
          $key = $context->key;
        }
        if (!configuration_reserved_attribute($key)) {
          $context->parent->{$key} = $context->item;
          unset($context->parent->item[$context->key]);
        }
      }
    break;
    case '#options callback':
      if (function_exists($value)) {
        $value = $value($context);
      }
    case '#options':
      if (is_scalar($value)) {
        $value = array($value);
      }
      
      if (!in_array($context->item, $value)) {
        if (!($context->item === '' && !$context->required)) {
          $path = implode('/', $context->trace);
          configuration_set_error('pre-validate: options', array('!path' => $path, '!options' => implode(', ', $value)));
          break;
        }
      }
    case '#value alias':
      foreach($value as $real => $aliases) {
        foreach($aliases as $alias) {
          if ($context->item == $alias) {
            $context->item = $real;
            break(2);
          }
        }
      }
    break;
    case '#value callback':
      if (function_exists($value)) {
        $value($context->item, $context);
      }
      else {
        configuration_set_error('value callback', array('@callback' => $value));
      }
    break;
    case '#value php':
      $php = $value;
      $value = &$context->item;
      $new = eval($php);
      if (isset($new)) {
        $context->item = $new;
      }
    break;
    case '#value path':
      if (($matches = configuration_fetch($value, $context)) && count($matches) == 1) {
        $context->item = $matches[0]->item;
      }
    break;
    case '#value':
      $context->item = $value;
    break;
    case '#id callback':
      if (function_exists($value)) {
        $identifiers =& configuration_get_data('identifiers');
      }
    break;
    case '#id php':
    
    break;
    case '#id path':
      
    break;
    // Not used/supported.
    // TODO Remove?
    case '#build callback':
      if (function_exists($value)) {
        $context->build_data = $value($context);
      }
    break;
    case '#build php':
      $context->build_data = eval($value);
    break;
    case '#action':
      if (!is_array($value)) {
        $value = array($value);
      }
      
      $actions =& configuration_get_data('actions');
      foreach($value as $action) {
        $action[] = array($action, null, &$context);
      }
    break;
    case '#action callback':
      if (function_exists($value)) {
        $actions =& configuration_get_data('actions');
        $context->action_callback = $value;
        $actions[] = array(null, &$context);
      }
      else {
        configuration_set_error('missing action callback', array('@callback' => $value));
      }
    break;
    case '#enable module':
      if (is_scalar($context->item)) {
        $enable =& configuration_get_data('enable modules');
        $enable[] = $context->item;
      }
    break;
    case '#disable module':
      if (is_scalar($context->item)) {
        $disable =& configuration_get_data('disable modules');
        $disable[] = $context->item;
      }
    break;
    case '#delete':
      unset($context->parent->item[$context->key]);
    break;
  }
  
  // Update the context object to reflect any possible new changes
  if (!in_array($property, $no_modify_propertiers)) {
    configuration_check_context($context);
  }
}

/**
 * Do the actual drupal execute on an action 
 */
function configuration_drupal_execute($form_id, &$form_state, $params) {
  // Make sure we always have a clear cache for everything
  $result = db_query('SHOW TABLES LIKE "cache_%"');

  while ($table = db_fetch_array($result)) {
    $table = current($table);
    cache_clear_all(null, $table);
  }

  // Perform direct and automatic manipulation of the configuration data
  // from the default fapi form object
  configuration_sync_data_form($form_state['values'], $form_id, $form_state, $params);

  $args = array($form_id, &$form_state);

  if (is_array($params)) {
    $args = array_merge($args, $params);
  }

  configuration_set_data('executing', true);

  // If we are in batch mode, trick the form api to think
  // otherwise to avoid potential problems
  $batch =& batch_get();
  $batch_clone = $batch;
  $batch = null;

  // drupal_execute fails to keep $form_state in-sync through the
  // whole FAPI process. Issue http://drupal.org/node/346244
  //$return = call_user_func_array('drupal_execute', $args);

  // Copy of drupal_execute until above issue is fixed
  $form = call_user_func_array('drupal_retrieve_form', $args);

  $form['#post'] = $form_state['values'];
  drupal_prepare_form($form_id, $form, $form_state);

  // If you call drupal_validate_form() on the same form more 
  // than once per page request, validation is not performed 
  // on any but the first call. 
  // see issue: http://drupal.org/node/260934
  // drupal_process_form($form_id, $form, $form_state);
  
  // Until above issue is fixed we use our own implementation 
  // of drupal_process_form() and drupal_validate_form(). 
  _configuration_process_form($form_id, $form, $form_state);

  configuration_set_data('executing', true);
  $batch = $batch_clone;
}

/**
 * Based on a form api array, make automatic modifications
 * to the form submission data.
 * 
 * What this can do:
 * 
 * 1. Check all #options and try and match the data to them. Example of why this is needed:
 *
 * XML syntax
 *    <types>page</types>
 *          OR
 *    <types>
 *      <type>page</type>
 *      <type>story</type>
 *    </types>
 * 
 * Original Results
 *  array(
 *    'types' => 'page'
 *  ) 
 *          OR
 *  array(
 *    'types' => array(
 *      'type' => array('page', 'store')
 *    )
 *  )
 * 
 * Desired Results
 * array(
 *  'types' => array(
 *    'page' => 'page'
 *  )
 * ) 
 *        OR
 * array(
 *  'types' => array(
 *    'page' => 'page',
 *    'story' => 'story'
 *  )
 * )
 * 
 * However in some cases the first example (<types>page</types>) would be in the form <type>page</type> without
 * the <types> parent and no need for the associative array. It would just be array('type' => 'page').
 *
 * Based off of the form api #options, #tree, and #multiple values, it should be possible to convert
 * any of the above xml objects to the right form api object.
 */
function configuration_sync_data_form(&$data, $form_id, $form_state, $params = null) {
  unset($form_state['values']);
  $args = array($form_id, &$form_state);
  if (is_array($params)) {
    $args = array_merge($args, $params);
  }

  // Get the fully built fapi object
  $form = call_user_func_array('drupal_retrieve_form', $args);
  drupal_prepare_form($form_id, $form, $form_state);
  $form = form_builder($form_id, $form, $form_state);

  $context = configuration_build_context($data);
  $form = configuration_build_context($form);
  
  // TODO Should we remove build data that does not exist in the form object?
  if ($form_matches = configuration_fetch('//#options', $form)) {
    for($i=0;isset($form_matches[$i]);$i++) {
      $form_match = &$form_matches[$i];

      // Check if we have this data
      $path = '/'. implode('/', $form_matches[$i]->parent->item['#parents']);
      if ($data_matches = configuration_fetch($path, $context)) {
        // Possibly manipulate our data to match these #options
        for($j=0;isset($data_matches[$j]);$j++) {
          $data_match = &$data_matches[$j];

          // Determine if this is a singular/scalar or arrayed element
          $scalar = false;
          if (!$form_match->parent->item['#tree'] || (isset($form_match->parent->item['#multiple']) && !$form_match->parent->item['#multiple'])) {
            $scalar = true;
          }
          // Setup the new value
          // TODO Actually implement the update vs overwrite functionality as opposed to the 100% update (true)
          if (true && !$scalar && !empty($form_match->parent->item['#default_value'])) {
            // Default values are not key=>key arrays like the post values. They are
            // indexed arrays. The below should catch an indexed array as well as a singular
            // scalar default value and turn it into a key=>key array
            $values = (array)$form_match->parent->item['#default_value'];
            $values = array_combine($values, $values);
          }
          else {
            $values = array();
          }
          foreach((array)$data_match->item as $value) {
            // If the supplied value matches an options label, use that option
            if ($key = array_search($value, $form_match->item)) {
              $values[$key] = $key;
            }
            // Or if the supplied value is an actual options value (not the label) use that
            else if (array_key_exists($value, $form_match->item)) {
              $values[$value] = $value;
            }
          }
          
          // If we are not on a multiple/tree form, the value should be singular/not an array
          if ($scalar) {
            $data_match->item = reset($values);
          }
          else {
            $data_match->item = $values;
          }
        }
      }
    }
  }
}

/**
 * Set the unique execution identifier for this configuration
 * 
 * @param $id
 *  The unique identifier for this execution run
 * @return
 *  The currently set identifier
 */
function configuration_set_current_id($id = null) {
  static $current_id;
  
  if ($id) {
    $current_id = $id;
  }

  return $current_id;
}

/**
 * Get the current configuration execution identifier
 */
function configuration_get_current_id() {
  return configuration_set_current_id();
}

/**
 * Set an error during configuration setup
 * 
 * @param $type
 *  The type of error being set.
 * @param $vars
 *  Any variables that are associated with the particular error
 * @param $cache
 *  This will set the static $errors cache
 * @return
 *  If $type is set, the error(s) for that type are returned. If not the entire
 *  static cache is returned.
 * //TODO Add a param to mark critical vs warning errors?
 */
function configuration_set_error($type = null, $vars = array()) {
  // Use the configuration data store instead of our own static cache here
  $errors =& configuration_set_data('errors');

  if ($type) {
    $errors[$type][] = $vars;
  }
  
  if ($type) {
    return $errors[$type];
  }
  else {
    return $errors;
  }
}

/**
 * Get any errors that have happened during configuration
 * 
 * @param $type
 *  The type of error being checked
 * @return
 *  The variable data stored for that particular error, if there is an error
 */
function configuration_get_error($type = null, &$vars = null) {
  $vars = configuration_set_error($type);

  // TODO Problem here
  if (isset($vars)) {
    return true;
  }
  else {
    return false;
  }
}

/**
 * Set static data to be retrieved during later phases
 * 
 * @param $type
 *  The type of data being stored, such as 'phase', 'build', 'action', 'cleanup' etc...
 * @param $data
 *  The actual data needing stored
 * @param $cache
 *  Set the full static $store of data with this $cache