Club Drupal

<?php

/**

 * @file

 * Conditional engine to process dependencies within the webform's conditionals.

 */

/**

 * Performs analysis and topological sorting on the conditionals.

 */

class WebformConditionals {

  /**

   * Define constants.

   *

   * Define constants for the result of an analysis of the conditionals on a

   * page for a given set of input values. Determines whether the component is

   * always hidden, always shown, or may or may not be shown depending upon

   * other values on the same page. In the last case, the component needs to be

   * rendered on the page because at least one source component is on the same

   * page. The field will be hidden with JavaScript.

   *

   * @var int

   */

  const componentHidden = 0;

  const componentShown = 1;

  const componentDependent = 2;

  protected static $conditionals = array();

  protected $node;

  protected $topologicalOrder;

  protected $pageMap;

  protected $childrenMap;

  protected $visibilityMap;

  protected $requiredMap;

  protected $setMap;

  protected $markupMap;

  public $errors;

  /**

   * Creates and caches a WebformConditional for a given node.

   */

  public static function factory($node) {

    if (!isset(self::$conditionals[$node->nid])) {

      self::$conditionals[$node->nid] = new WebformConditionals($node);

    }

    return self::$conditionals[$node->nid];

  }

  /**

   * Constructs a WebformConditional.

   */

  public function __construct($node) {

    $this->node = $node;

  }

  /**

   * Sorts the conditionals into topological order.

   *

   * The "nodes" of the list are the conditionals, not the components that

   * they operate upon.

   *

   * The webform components must already be sorted into component tree order

   * before calling this method.

   *

   * See http://en.wikipedia.org/wiki/Topological_sorting

   */

  protected function topologicalSort() {

    $components = $this->node->webform['components'];

    $conditionals = $this->node->webform['conditionals'];

    $errors = array();

    // Generate a component to conditional map for conditional targets.

    $cid_to_target_rgid = array();

    $cid_hidden = array();

    foreach ($conditionals as $rgid => $conditional) {

      foreach ($conditional['actions'] as $aid => $action) {

        $target_id = $action['target'];

        $cid_to_target_rgid[$target_id][$rgid] = $rgid;

        if ($action['action'] == 'show') {

          $cid_hidden[$target_id] = isset($cid_hidden[$target_id]) ? $cid_hidden[$target_id] + 1 : 1;

          if ($cid_hidden[$target_id] == 2) {

            $component = $components[$target_id];

            $errors[$component['page_num']][] = t('More than one conditional hides or shows component "@name".',

                                                  array('@name' => $component['name']));

          }

        }

      }

    }

    // Generate T-Orders for each page.

    $new_entry = array('in' => array(), 'out' => array(), 'rgid' => array());

    $page_num = 0;

    // If the first component is a page break, then no component is on page 1. Create empty arrays for page 1.

    $sorted = array(1 => array());

    $page_map = array(1 => array());

    $component = reset($components);

    while ($component) {

      $cid = $component['cid'];

      // Start a new page, if needed.

      if ($component['page_num'] > $page_num) {

        $page_num = $component['page_num'];

        // Create an empty list that will contain the sorted elements.

        // This list is known as L in the literature.

        $sorted[$page_num] = array();

        // Create an empty list of dependency nodes for this page.

        $nodes = array();

      }

      // Create the pageMap as a side benefit of generating the t-sort.

      $page_map[$page_num][$cid] = $cid;

      // Process component by adding it's conditional data to a component-tree-traversal order an index of:

      // - incoming dependencies = the source components for the conditions for this target component and

      // - outgoing dependencies = components which depend upon the target component

      // Note: Surprisingly, 0 is a valid rgid, as well as a valid rid. Use -1 as a semaphore.

      if (isset($cid_to_target_rgid[$cid])) {

        // The component is the target of conditional(s)

        foreach ($cid_to_target_rgid[$cid] as $rgid) {

          $conditional = $conditionals[$rgid];

          if (!isset($nodes[$cid])) {

            $nodes[$cid] = $new_entry;

          }

          $nodes[$cid]['rgid'][$rgid] = $rgid;

          foreach ($conditional['rules'] as $rule) {

            if ($rule['source_type'] == 'component') {

              $source_id = $rule['source'];

              if (!isset($nodes[$source_id])) {

                $nodes[$source_id] = $new_entry;

              }

              $nodes[$cid]['in'][$source_id] = $source_id;

              $nodes[$source_id]['out'][$cid] = $cid;

              $source_component = $components[$source_id];

              $source_pid = $source_component['pid'];

              if ($source_pid) {

                if (!isset($nodes[$source_pid])) {

                  $nodes[$source_pid] = $new_entry;

                }

                // The rule source is within a parent fieldset. Create a dependency on the parent.

                $nodes[$source_pid]['out'][$source_id] = $source_id;

                $nodes[$source_id]['in'][$source_pid] = $source_pid;

              }

              if ($source_component['page_num'] > $page_num) {

                $errors[$page_num][] = t('A forward reference from page @from, %from to %to was found.',

                  array(

                    '%from' => $source_component['name'],

                    '@from' => $source_component['page_num'],

                    '%to' => $component['name'],

                  ));

              }

              elseif ($source_component['page_num'] == $page_num && $component['type'] == 'pagebreak') {

                $errors[$page_num][] = t('The page break %to can\'t be controlled by %from on the same page.',

                  array(

                    '%from' => $source_component['name'],

                    '%to' => $component['name'],

                  ));

              }

            }

          }

        }

      }

      // Fetch the next component, if any.

      $component = next($components);

      // Finish any previous page already processed.

      if (!$component || $component['page_num'] > $page_num) {

        // Create a set of all components which have are not dependent upon anything.

        // This list is known as S in the literature.

        $start_nodes = array();

        foreach ($nodes as $id => $n) {

          if (!$n['in']) {

            $start_nodes[] = $id;

          }

        }

        // Process the start nodes, removing each one in turn from the queue.

        while ($start_nodes) {

          $id = array_shift($start_nodes);

          // If the node represents an actual conditional, it can now be added

          // to the end of the sorted order because anything it depends upon has

          // already been calculated.

          if ($nodes[$id]['rgid']) {

            foreach ($nodes[$id]['rgid'] as $rgid) {

              $sorted[$page_num][] = array(

                'cid' => $id,

                'rgid' => $rgid,

                'name' => $components[$id]['name'],

              );

            }

          }

          // Any other nodes that depend upon this node may now have their dependency

          // on this node removed, since it has now been calculated.

          foreach ($nodes[$id]['out'] as $out_id) {

            unset($nodes[$out_id]['in'][$id]);

            if (!$nodes[$out_id]['in']) {

              $start_nodes[] = $out_id;

            }

          }

          // All out-going dependencies have been handled.

          $nodes[$id]['out'] = array();

        }

        // Check for a cyclic graph (circular dependency).

        foreach ($nodes as $id => $n) {

          if ($n['in'] || $n['out']) {

            $errors[$page_num][] = t('A circular reference involving %name was found.',

              array('%name' => $components[$id]['name']));

          }

        }

      } // End finishing previous page.

    } // End component loop.

    // Create an empty page map for the preview page.

    $page_map[$page_num + 1] = array();

    $this->topologicalOrder = $sorted;

    $this->errors = $errors;

    $this->pageMap = $page_map;

  }

  /**

   * Returns the (possibly cached) topological sort order.

   */

  public function getOrder() {

    if (!$this->topologicalOrder) {

      $this->topologicalSort();

    }

    return $this->topologicalOrder;

  }

  /**

   * Returns an index of components by page number.

   */

  public function getPageMap() {

    if (!$this->pageMap) {

      $this->topologicalSort();

    }

    return $this->pageMap;

  }

  /**

   * Displays and error messages from the previously-generated sort order.

   *

   * User's who can't fix the webform are shown a single, simplified message.

   */

  public function reportErrors() {

    $this->getOrder();

    if ($this->errors) {

      if (webform_node_update_access($this->node)) {

        foreach ($this->errors as $page_num => $page_errors) {

          drupal_set_message(format_plural(count($page_errors),

            'Conditional error on page @num:',

            'Conditional errors on page @num:',

            array('@num' => $page_num)) .

            '<br /><ul><li>' . implode('</li><li>', $page_errors) . '</li></ul>', 'warning');

        }

      }

      else {

        drupal_set_message(t('This form is improperly configured. Contact the administrator.'), 'warning');

      }

    }

  }

  /**

   * Creates and caches a map of the children of a each component.

   *

   * Called after the component tree has been made and then flattened again.

   * Alas, the children data is removed when the tree is flattened. The

   * components are indexed by cid but in tree order. Because cid's are

   * numeric, they may not appear in IDE's or debuggers in their actual order.

   */

  public function getChildrenMap() {

    if (!$this->childrenMap) {

      $map = array();

      foreach ($this->node->webform['components'] as $cid => $component) {

        $pid = $component['pid'];

        if ($pid) {

          $map[$pid][] = $cid;

        }

      }

      $this->childrenMap = $map;

    }

    return $this->childrenMap;

  }

  /**

   * Deletes the value of the given component, plus any descendants.

   */

  protected function deleteFamily(&$input_values, $parent_id, &$page_visiblity_page) {

    if (isset($input_values[$parent_id])) {

      $input_values[$parent_id] = NULL;

    }

    if (isset($this->childrenMap[$parent_id])) {

      foreach ($this->childrenMap[$parent_id] as $child_id) {

        $page_visiblity_page[$child_id] = $page_visiblity_page[$parent_id];

        $this->deleteFamily($input_values, $child_id, $page_visiblity_page);

      }

    }

  }

  protected $stackPointer;

  protected $resultStack;

  /**

   * Initializes an execution stack for a conditional group's rules.

   *

   * Also initializes sub-conditional rules.

   */

  public function executionStackInitialize($andor) {

    $this->stackPointer = -1;

    $this->resultStack = array();

    $this->executionStackPush($andor);

  }

  /**

   * Starts a new subconditional for the given and/or operator.

   */

  public function executionStackPush($andor) {

    $this->resultStack[++$this->stackPointer] = array(

      'results' => array(),

      'andor' => $andor,

    );

  }

  /**

   * Adds a rule's result to the current sub-conditional.

   */

  public function executionStackAccumulate($result) {

    $this->resultStack[$this->stackPointer]['results'][] = $result;

  }

  /**

   * Finishes a sub-conditional and adds the result to the parent stack frame.

   */

  public function executionStackPop() {

    // Calculate the and/or result.

    $stack_frame = $this->resultStack[$this->stackPointer];

    // Pop stack and protect against stack underflow.

    $this->stackPointer = max(0, $this->stackPointer - 1);

    $conditional_results = $stack_frame['results'];

    $filtered_results = array_filter($conditional_results);

    return $stack_frame['andor'] === 'or'

              ? count($filtered_results) > 0

              : count($filtered_results) === count($conditional_results);

  }

  /**

   * Executes the conditionals on a submission.

   *

   * This removes any data which should be hidden.

   */

  public function executeConditionals($input_values, $page_num = 0) {

    $this->getOrder();

    $this->getChildrenMap();

    if (!$this->visibilityMap || $page_num == 0) {

      // Create a new visibility map, with all components shown.

      $this->visibilityMap = $this->pageMap;

      array_walk_recursive($this->visibilityMap, function (&$status) {

        $status = WebformConditionals::componentShown;

      });

      // Create empty required, set, and markup maps.

      $this->requiredMap = array_fill(1, count($this->pageMap), array());

      $this->setMap = $this->requiredMap;

      $this->markupMap = $this->requiredMap;

    }

    else {

      array_walk($this->visibilityMap[$page_num], function (&$status) {

        $status = WebformConditionals::componentShown;

      });

      $this->requiredMap[$page_num] = array();

      $this->setMap[$page_num] = array();

      $this->markupMap[$page_num] = array();

    }

    module_load_include('inc', 'webform', 'includes/webform.conditionals');

    $components = $this->node->webform['components'];

    $conditionals = $this->node->webform['conditionals'];

    $operators = webform_conditional_operators();

    $targetLocked = array();

    $first_page = $page_num ? $page_num : 1;

    $last_page = $page_num ? $page_num : count($this->topologicalOrder);

    for ($page = $first_page; $page <= $last_page; $page++) {

      foreach ($this->topologicalOrder[$page] as $conditional_spec) {

        $conditional = $conditionals[$conditional_spec['rgid']];

        $source_page_nums = array();

        // Execute each comparison callback.

        $this->executionStackInitialize($conditional['andor']);

        foreach ($conditional['rules'] as $rule) {

          switch ($rule['source_type']) {

            case 'component':

              $source_component = $components[$rule['source']];

              $source_cid = $source_component['cid'];

              $source_values = array();

              if (isset($input_values[$source_cid])) {

                $component_value = $input_values[$source_cid];

                // For select_or_other components, use only the select values because $source_values must not be a nested array.

                // During preview, the array is already flattened.

                if ($source_component['type'] === 'select' &&

                    !empty($source_component['extra']['other_option']) &&

                    isset($component_value['select'])) {

                  $component_value = $component_value['select'];

                }

                $source_values = is_array($component_value) ? $component_value : array($component_value);

              }

              // Determine the operator and callback.

              $conditional_type = webform_component_property($source_component['type'], 'conditional_type');

              $operator_info = $operators[$conditional_type];

              // Perform the comparison callback and build the results for this group.

              $comparison_callback = $operator_info[$rule['operator']]['comparison callback'];

              // Contrib caching, such as entitycache, may have loaded the node

              // without building it. It is possible that the component include file

              // hasn't been included yet. See #2529246.

              webform_component_include($source_component['type']);

              // Load missing include files for conditional types.

              // In the case of the 'string', 'date', and 'time' conditional types, it is

              // not necessary to load their include files for conditional behavior

              // because the required functions are already loaded

              // in webform.conditionals.inc.

              switch ($conditional_type) {

                case 'numeric':

                  module_load_include('inc', 'webform', 'components/number');

                  break;

                case 'select':

                  module_load_include('inc', 'webform', 'components/select');

                  break;

              }

              $this->executionStackAccumulate($comparison_callback($source_values, $rule['value'], $source_component));

              // Record page number to later determine any intra-page dependency on this source.

              $source_page_nums[$source_component['page_num']] = $source_component['page_num'];

              break;

            case 'conditional_start':

              $this->executionStackPush($rule['operator']);

              break;

            case 'conditional_end':

              $this->executionStackAccumulate($this->executionStackPop());

              break;

          }

        }

        $conditional_result = $this->executionStackPop();

        foreach ($conditional['actions'] as $action) {

          $action_result = $action['invert'] ? !$conditional_result : $conditional_result;

          $target = $action['target'];

          $page_num = $components[$target]['page_num'];

          switch ($action['action']) {

            case 'show':

              if (!$action_result) {

                $this->visibilityMap[$page_num][$target] = in_array($page_num, $source_page_nums) ? self::componentDependent : self::componentHidden;

                $this->deleteFamily($input_values, $target, $this->visibilityMap[$page_num]);

                $targetLocked[$target] = TRUE;

              }

              break;

            case 'require':

              $this->requiredMap[$page_num][$target] = $action_result;

              break;

            case 'set':

              if ($components[$target]['type'] == 'markup') {

                $this->markupMap[$page_num][$target] = FALSE;

              }

              if ($action_result && empty($targetLocked[$target])) {

                if ($components[$target]['type'] == 'markup') {

                  $this->markupMap[$page_num][$target] = $action['argument'];

                }

                else {

                  $input_values[$target] = isset($input_values[$target]) && is_array($input_values[$target])

                                              ? array($action['argument'])

                                              : $action['argument'];

                  $this->setMap[$page_num][$target] = TRUE;

                }

              }

              break;

          }

        }

      } // End conditinal loop

    } // End page loop

    return $input_values;

  }

  /**

   * Returns whether the conditionals have been executed yet.

   */

  public function isExecuted() {

    return (boolean) ($this->visibilityMap);

  }

  /**

   * Returns the required status for a component.

   *

   * Returns whether a given component is always hidden, always shown, or might

   * be shown depending upon other sources on the same page.

   *

   * Assumes that the conditionals have already been executed on the given page.

   *

   * @param int $cid

   *   The component id of the component whose visibility is being sought.

   * @param int $page_num

   *   The page number that the component is on.

   *

   * @return int

   *   self::componentHidden, ...Shown, or ...Dependent.

   */

  public function componentVisibility($cid, $page_num) {

    if (!$this->visibilityMap) {

      // The conditionals have not yet been executed on a submission.

      $this->executeConditionals(array(), 0);

      watchdog('webform', 'WebformConditionals::componentVisibility called prior to evaluating a submission.', array(), WATCHDOG_ERROR);

    }

    return isset($this->visibilityMap[$page_num][$cid]) ? $this->visibilityMap[$page_num][$cid] : self::componentShown;

  }

  /**

   * Returns whether a given page should be displayed.

   *

   * This requires any conditional for the page itself to be shown, plus at

   * least one component within the page must be shown too. The first and

   * preview pages are always shown, however.

   *

   * @param int $page_num

   *   The page number that the component is on.

   *

   * @return int

   *   self::componentHidden or  ...Shown.

   */

  public function pageVisibility($page_num) {

    $result = self::componentHidden;

    if ($page_num == 1 || empty($this->visibilityMap[$page_num])) {

      $result = self::componentShown;

    }

    elseif (($page_map = $this->pageMap[$page_num]) && $this->componentVisibility(reset($page_map), $page_num)) {

      while ($cid = next($page_map)) {

        if ($this->componentVisibility($cid, $page_num) != self::componentHidden) {

          $result = self::componentShown;

          break;

        }

      }

    }

    return $result;

  }

  /**

   * Returns the required status for a component.

   *

   * Returns whether a given component is always required, always optional, or

   * unchanged by conditional logic.

   *

   * Assumes that the conditionals have already been executed on the given page.

   *

   * @param int $cid

   *   The component id of the component whose required state is being sought.

   * @param int $page_num

   *   The page number that the component is on.

   *

   * @return bool

   *   Whether the component is required based on conditionals.

   */

  public function componentRequired($cid, $page_num) {

    if (!$this->requiredMap) {

      // The conditionals have not yet been executed on a submission.

      $this->executeConditionals(array(), 0);

      watchdog('webform', 'WebformConditionals::componentRequired called prior to evaluating a submission.', array(), WATCHDOG_ERROR);

    }

    return isset($this->requiredMap[$page_num][$cid]) ? $this->requiredMap[$page_num][$cid] : NULL;

  }

  /**

   * Returns whether a given component has been set by conditional logic.

   *

   * Assumes that the conditionals have already been executed on the given page.

   *

   * @param int $cid

   *   The component id of the component whose set state is being sought.

   * @param int $page_num

   *   The page number that the component is on.

   *

   * @return bool

   *   Whether the component was set based on conditionals.

   */

  public function componentSet($cid, $page_num) {

    if (!$this->setMap) {

      // The conditionals have not yet been executed on a submission.

      $this->executeConditionals(array(), 0);

      watchdog('webform', 'WebformConditionals::componentSet called prior to evaluating a submission.', array(), WATCHDOG_ERROR);

    }

    return isset($this->setMap[$page_num][$cid]) ? $this->setMap[$page_num][$cid] : NULL;

  }

  /**

   * Returns the calculated markup as set by conditional logic.

   *

   * Assumes that the conditionals have already been executed on the given page.

   *

   * @param int $cid

   *   The component id of the component whose set state is being sought.

   * @param int $page_num

   *   The page number that the component is on.

   *

   * @return string

   *   The conditional markup, or NULL if none.

   */

  public function componentMarkup($cid, $page_num) {

    if (!$this->markupMap) {

      // The conditionals have not yet been executed on a submission.

      $this->executeConditionals(array(), 0);

      watchdog('webform', 'WebformConditionals::componentMarkup called prior to evaluating a submission.', array(), WATCHDOG_ERROR);

    }

    return isset($this->markupMap[$page_num][$cid]) ? $this->markupMap[$page_num][$cid] : NULL;

  }

}