class Rule in Rules 7.2

An actual rule.

Note: A rule also implements the RulesActionInterface (inherited).

Hierarchy

class \RulesExtendable extends \FacesExtendable
- class \RulesPlugin
  - class \RulesContainerPlugin implements \IteratorAggregate
    class \RulesActionContainer implements RulesActionInterface
    class \Rule

Expanded class hierarchy of Rule

3 string references to 'Rule'

hook_rules_plugin_info in ./rules.api.php: Defines rules plugins.
rules_drush_command in ./rules.drush.inc: Implements hook_drush_command().
rules_rules_plugin_info in ./rules.module: Implements hook_rules_plugin_info().

File

includes/rules.plugins.inc, line 162: Contains plugin info and implementations not needed for rule evaluation.

View source

class Rule extends RulesActionContainer {
  protected $conditions = NULL;

  /**
   * @var string
   */
  protected $itemName = 'rule';

  /**
   * @var string
   */
  public $label = 'unlabeled';
  public function __construct($variables = array(), $providesVars = array()) {
    parent::__construct($variables, $providesVars);

    // Initialize the conditions container.
    if (!isset($this->conditions)) {
      $this->conditions = rules_and();

      // Don't use setParent() to avoid having it added to the children.
      $this->conditions->parent = $this;
    }
  }

  /**
   * Gets an iterator over all contained conditions.
   *
   * Note that this iterator also implements the ArrayAccess interface.
   *
   * @return RulesRecursiveElementIterator
   */
  public function conditions() {
    return $this->conditions
      ->getIterator();
  }

  /**
   * Returns the "And" condition container, which contains all conditions of
   * this rule.
   *
   * @return RulesAnd
   */
  public function conditionContainer() {
    return $this->conditions;
  }
  public function __sleep() {
    return parent::__sleep() + drupal_map_assoc(array(
      'conditions',
      'label',
    ));
  }

  /**
   * Gets an iterator over all contained actions.
   *
   * Note that this iterator also implements the ArrayAccess interface.
   *
   * @return RulesRecursiveElementIterator
   */
  public function actions() {
    return parent::getIterator();
  }

  /**
   * Adds a condition.
   *
   * Pass either an instance of the RulesConditionInterface or the arguments as
   * needed by rules_condition().
   *
   * @return $this
   */
  public function condition($name, $settings = array()) {
    $this->conditions
      ->condition($name, $settings);
    return $this;
  }
  public function sortChildren($deep = FALSE) {
    $this->conditions
      ->sortChildren($deep);
    parent::sortChildren($deep);
  }
  public function evaluate(RulesState $state) {
    rules_log('Evaluating conditions of rule %label.', array(
      '%label' => $this->label,
    ), RulesLog::INFO, $this);
    if ($this->conditions
      ->evaluate($state)) {
      rules_log('Rule %label fires.', array(
        '%label' => $this->label,
      ), RulesLog::INFO, $this, TRUE);
      parent::evaluate($state);
      rules_log('Rule %label has fired.', array(
        '%label' => $this->label,
      ), RulesLog::INFO, $this, FALSE);
    }
  }

  /**
   * Fires the rule, i.e. evaluates the rule without checking its conditions.
   *
   * @see RulesPlugin::evaluate()
   */
  public function fire(RulesState $state) {
    rules_log('Firing rule %label.', array(
      '%label' => $this->label,
    ), RulesLog::INFO, $this);
    parent::evaluate($state);
  }
  public function integrityCheck() {
    parent::integrityCheck();
    $this->conditions
      ->integrityCheck();
    return $this;
  }
  public function access() {
    return (!isset($this->conditions) || $this->conditions
      ->access()) && parent::access();
  }
  public function dependencies() {
    return array_keys(array_flip($this->conditions
      ->dependencies()) + array_flip(parent::dependencies()));
  }
  public function destroy() {
    $this->conditions
      ->destroy();
    parent::destroy();
  }

  /**
   * @return RulesRecursiveElementIterator
   */
  public function getIterator() {
    $array = array_merge(array(
      $this->conditions,
    ), $this->children);
    return new RulesRecursiveElementIterator($array);
  }
  protected function stateVariables($element = NULL) {

    // Don't add in provided action variables for the conditions.
    if (isset($element) && $element === $this->conditions) {
      return $this
        ->availableVariables();
    }
    $vars = parent::stateVariables($element);

    // Take variable info assertions of conditions into account.
    if ($assertions = $this->conditions
      ->variableInfoAssertions()) {
      $vars = RulesData::addMetadataAssertions($vars, $assertions);
    }
    return $vars;
  }
  protected function exportFlat() {
    return $this
      ->isRoot();
  }
  protected function exportToArray() {
    $export = parent::exportToArray();
    if (!$this
      ->isRoot()) {
      $export[strtoupper($this
        ->plugin())]['LABEL'] = $this->label;
    }
    return $export;
  }
  protected function exportChildren($key = NULL) {
    $export = array();
    if ($this->conditions->children) {
      $export = $this->conditions
        ->exportChildren('IF');
    }
    return $export + parent::exportChildren('DO');
  }
  public function import(array $export) {
    if (!$this
      ->isRoot() && isset($export[strtoupper($this
      ->plugin())]['LABEL'])) {
      $this->label = $export[strtoupper($this
        ->plugin())]['LABEL'];
    }
    parent::import($export);
  }
  protected function importChildren($export, $key = NULL) {
    if (!empty($export['IF'])) {
      $this->conditions
        ->importChildren($export, 'IF');
    }
    parent::importChildren($export, 'DO');
  }
  public function __clone() {
    parent::__clone();
    $this->conditions = clone $this->conditions;
    $this->conditions->parent = $this;
  }

  /**
   * Overrides RulesPlugin::variableInfoAssertions().
   *
   * Rules may not provide any variable info assertions, as Rules are only
   * conditionally executed.
   */
  protected function variableInfoAssertions() {
    return array();
  }

  /**
   * Overridden to ensure the whole Rule is deleted at once.
   */
  public function delete($keep_children = FALSE) {
    parent::delete($keep_children);
  }

  /**
   * Overridden to expose the variables of all actions for embedded rules.
   */
  public function providesVariables() {
    $provides = parent::providesVariables();
    if (!$this
      ->isRoot()) {
      foreach ($this
        ->actions() as $action) {
        $provides += $action
          ->providesVariables();
      }
    }
    return $provides;
  }
  public function resetInternalCache() {
    parent::resetInternalCache();
    $this->conditions
      ->resetInternalCache();
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Rule::$conditions	protected	property
Rule::$itemName	protected	property	Overrides RulesExtendable::$itemName
Rule::$label	public	property
Rule::access	public	function	Whether the currently logged in user has access to all configured elements. Overrides RulesContainerPlugin::access
Rule::actions	public	function	Gets an iterator over all contained actions.
Rule::condition	public	function	Adds a condition.
Rule::conditionContainer	public	function	Returns the "And" condition container, which contains all conditions of this rule.
Rule::conditions	public	function	Gets an iterator over all contained conditions.
Rule::delete	public	function	Overridden to ensure the whole Rule is deleted at once. Overrides RulesContainerPlugin::delete
Rule::dependencies	public	function	Calculates an array of required modules. Overrides RulesContainerPlugin::dependencies
Rule::destroy	public	function	Removes circular object references so PHP garbage collector can work. Overrides RulesContainerPlugin::destroy
Rule::evaluate	public	function	Evaluate, whereas by default new vars are visible in the parent's scope. Overrides RulesActionContainer::evaluate
Rule::exportChildren	protected	function	Overrides RulesContainerPlugin::exportChildren
Rule::exportFlat	protected	function	Determines whether the element should be exported in flat style. Overrides RulesContainerPlugin::exportFlat
Rule::exportToArray	protected	function	Overrides RulesActionContainer::exportToArray
Rule::fire	public	function	Fires the rule, i.e. evaluates the rule without checking its conditions.
Rule::getIterator	public	function	Overrides RulesContainerPlugin::getIterator
Rule::import	public	function	Applies the given export. Overrides RulesActionContainer::import
Rule::importChildren	protected	function	Overrides RulesContainerPlugin::importChildren
Rule::integrityCheck	public	function	Makes sure the plugin is configured right. Overrides RulesContainerPlugin::integrityCheck
Rule::providesVariables	public	function	Overridden to expose the variables of all actions for embedded rules. Overrides RulesActionContainer::providesVariables
Rule::resetInternalCache	public	function	Resets any internal static caches. Overrides RulesContainerPlugin::resetInternalCache
Rule::sortChildren	public	function	Sorts all child elements by their weight. Overrides RulesContainerPlugin::sortChildren
Rule::stateVariables	protected	function	Returns available state variables for an element. Overrides RulesContainerPlugin::stateVariables
Rule::variableInfoAssertions	protected	function	Overrides RulesPlugin::variableInfoAssertions(). Overrides RulesContainerPlugin::variableInfoAssertions
Rule::__clone	public	function	By default we do a deep clone. Overrides RulesContainerPlugin::__clone
Rule::__construct	public	function	Overrides RulesActionContainer::__construct
Rule::__sleep	public	function	Overrides RulesContainerPlugin::__sleep
RulesActionContainer::action	public	function	Adds an action to the container.
RulesActionContainer::componentProvidesVariables	public	function	Returns an array of provided variable names.
RulesActionContainer::pluginProvidesVariables	public	function	Returns info about variables 'provided' by the plugin. Overrides RulesPlugin::pluginProvidesVariables
RulesContainerPlugin::$children	protected	property
RulesContainerPlugin::availableVariables	public	function	Returns info about variables available to be used as arguments for this element. Overrides RulesPlugin::availableVariables
RulesContainerPlugin::componentVariables	public	function	Returns the specified variables, in case the plugin is used as component.
RulesContainerPlugin::executeByArgs	public	function	Executes container with the given arguments. Overrides RulesPlugin::executeByArgs	1
RulesContainerPlugin::optimize	public	function	Overrides optimize(). Overrides RulesPlugin::optimize
RulesContainerPlugin::parameterInfo	public	function	Returns info about parameters needed for executing the configured plugin. Overrides RulesPlugin::parameterInfo
RulesContainerPlugin::setUpVariables	protected	function	Returns info about all variables that have to be setup in the state. Overrides RulesPlugin::setUpVariables
RulesExtendable::$itemInfo	protected	property
RulesExtendable::facesAs	public	function
RulesExtendable::forceSetUp	public	function	Forces the object to be setUp, this executes setUp() if not done yet.	1
RulesExtendable::itemFacesAs	public static	function	Returns whether the a RuleExtendable supports the given interface.
RulesExtendable::rebuildCache	public	function	Allows items to add something to the rules cache.	1
RulesExtendable::setUp	protected	function		1
RulesExtendable::__call	public	function	Magic method: Invoke the dynamically implemented methods.
RulesPlugin::$availableVariables	protected	property	Static cache for availableVariables().	1
RulesPlugin::$cache	protected	property	Overrides RulesExtendable::$cache
RulesPlugin::$elementId	protected	property	Identifies an element inside a configuration.
RulesPlugin::$hook	protected	property	Overrides RulesExtendable::$hook
RulesPlugin::$id	public	property	If this is a configuration saved to the db, the id of it.
RulesPlugin::$info	protected	property	Info about this element. Usage depends on the plugin.	2
RulesPlugin::$name	public	property
RulesPlugin::$parent	protected	property	The parent element, if any.
RulesPlugin::$settings	public	property	An array of settings for this element.
RulesPlugin::$weight	public	property
RulesPlugin::applyDataSelector	public	function	Applies the given data selector.
RulesPlugin::checkParameterSettings	protected	function	Checks whether parameters are correctly configured.
RulesPlugin::checkVarName	protected	function
RulesPlugin::compare	protected static	function
RulesPlugin::depth	public	function	Returns the depth of this element in the configuration.
RulesPlugin::elementId	public	function	Returns the element id, which identifies the element inside the config.
RulesPlugin::elementMap	public	function	Gets the element map helper object, which helps mapping elements to ids.
RulesPlugin::elements	public	function	Iterate over all elements nested below the current element.
RulesPlugin::ensureNameExists	protected	function	Ensure the configuration has a name. If not, generate one.
RulesPlugin::entityInfo	public	function
RulesPlugin::entityType	public	function
RulesPlugin::execute	public	function	Execute the configuration.
RulesPlugin::export	public	function	Exports a rule configuration.
RulesPlugin::exportParameterSetting	protected	function
RulesPlugin::exportSettings	protected	function		1
RulesPlugin::form	public	function	Seamlessly invokes the method implemented via faces.
RulesPlugin::form_submit	public	function
RulesPlugin::form_validate	public	function
RulesPlugin::getArgument	protected	function	Returns the argument for the parameter $name described with $info.
RulesPlugin::getArgumentInfo	public	function	Returns info about the configured argument.
RulesPlugin::getExecutionArguments	protected	function	Gets the right arguments for executing the element.
RulesPlugin::getPluginName	public	function	Gets the name of this plugin instance.	1
RulesPlugin::hasStatus	public	function	Checks if the configuration has a certain exportable status.
RulesPlugin::identifier	public	function	Returns the config name.
RulesPlugin::importParameterSetting	protected	function
RulesPlugin::importSettings	protected	function		1
RulesPlugin::info	public	function	Returns the info of the plugin.	2
RulesPlugin::internalIdentifier	public	function
RulesPlugin::isRoot	public	function	Returns whether the element is the root of the configuration.
RulesPlugin::label	public	function	Returns the label of the element.	4
RulesPlugin::parentElement	public	function	Returns the element's parent.
RulesPlugin::plugin	public	function	Returns the name of the element's plugin.
RulesPlugin::pluginInfo	public	function	Returns info about the element's plugin.
RulesPlugin::pluginParameterInfo	public	function	Returns info about parameters needed by the plugin.	2
RulesPlugin::processSettings	public	function	Processes the settings e.g. to prepare input evaluators.	1
RulesPlugin::returnExport	protected	function	Finalizes the configuration export.
RulesPlugin::returnVariables	protected	function	Gets variables to return once the configuration has been executed.	2
RulesPlugin::root	public	function	Gets the root element of the configuration.
RulesPlugin::save	public	function	Saves the configuration to the database.	1
RulesPlugin::setParent	public	function	Sets a new parent element.
RulesPlugin::setUpState	public	function	Sets up the execution state for the given arguments.
RulesPlugin::__toString	public	function	When converted to a string, just use the export format.

You are here

class Rule in Rules 7.2

Hierarchy

File

Members

API Navigation