class RulesLoop

A loop element.

Hierarchy

Expanded class hierarchy of RulesLoop

1 string reference to 'RulesLoop'
rules_rules_plugin_info in ./rules.module
Implements hook_rules_plugin_info().

File

includes/rules.plugins.inc, line 658

View source
class RulesLoop extends RulesActionContainer {
    
    /**
     * @var string
     */
    protected $itemName = 'loop';
    protected $listItemInfo;
    public function __construct($settings = array(), $variables = NULL) {
        $this->setUp();
        $this->settings = (array) $settings + array(
            'item:var' => 'list_item',
            'item:label' => t('Current list item'),
        );
        if (!empty($variables)) {
            $this->info['variables'] = $variables;
        }
    }
    public function pluginParameterInfo() {
        $info['list'] = array(
            'type' => 'list',
            'restriction' => 'selector',
            'label' => t('List'),
            'description' => t('The list to loop over. The loop will step through each item in the list, allowing further actions on them. See <a href="@url"> the online handbook</a> for more information on how to use loops.', array(
                '@url' => rules_external_help('loops'),
            )),
        );
        return $info;
    }
    public function integrityCheck() {
        parent::integrityCheck();
        $this->checkVarName($this->settings['item:var']);
    }
    public function listItemInfo() {
        if (!isset($this->listItemInfo)) {
            if ($info = $this->getArgumentInfo('list')) {
                // Pass through the variable info keys like property info.
                $this->listItemInfo = array_intersect_key($info, array_flip(array(
                    'type',
                    'property info',
                    'bundle',
                )));
                $this->listItemInfo['type'] = isset($info['type']) ? entity_property_list_extract_type($info['type']) : 'unknown';
            }
            else {
                $this->listItemInfo = array(
                    'type' => 'unknown',
                );
            }
            $this->listItemInfo['label'] = $this->settings['item:label'];
        }
        return $this->listItemInfo;
    }
    public function evaluate(RulesState $state) {
        try {
            $param_info = $this->pluginParameterInfo();
            $list = $this->getArgument('list', $param_info['list'], $state);
            $item_var_info = $this->listItemInfo();
            $item_var_name = $this->settings['item:var'];
            if (isset($this->settings['list:select'])) {
                rules_log('Looping over the list items of %selector', array(
                    '%selector' => $this->settings['list:select'],
                ), RulesLog::INFO, $this);
            }
            // Loop over the list and evaluate the children for each list item.
            foreach ($list as $key => $item) {
                // Use a separate state so variables are available in the loop only.
                $state2 = clone $state;
                $state2->addVariable($item_var_name, $list[$key], $item_var_info);
                parent::evaluate($state2);
                // Update variables from parent scope.
                foreach ($state->variables as $var_key => &$var_value) {
                    if (array_key_exists($var_key, $state2->variables)) {
                        $var_value = $state2->variables[$var_key];
                    }
                }
            }
        } catch (RulesEvaluationException $e) {
            rules_log($e->msg, $e->args, $e->severity);
            rules_log('Unable to evaluate %name.', array(
                '%name' => $this->getPluginName(),
            ), RulesLog::WARN, $this);
        }
    }
    protected function stateVariables($element = NULL) {
        return array(
            $this->settings['item:var'] => $this->listItemInfo(),
        ) + parent::stateVariables($element);
    }
    public function label() {
        return !empty($this->label) ? $this->label : t('Loop');
    }
    protected function exportChildren($key = 'DO') {
        return parent::exportChildren($key);
    }
    protected function importChildren($export, $key = 'DO') {
        parent::importChildren($export, $key);
    }
    protected function exportSettings() {
        $export = parent::exportSettings();
        $export['ITEM'][$this->settings['item:var']] = $this->settings['item:label'];
        return $export;
    }
    protected function importSettings($export) {
        parent::importSettings($export);
        if (isset($export['ITEM'])) {
            $this->settings['item:var'] = rules_array_key($export['ITEM']);
            $this->settings['item:label'] = reset($export['ITEM']);
        }
    }

}

Members

Title Sort descending Modifiers Object type Summary Overriden Title Overrides
RulesActionContainer::action public function Adds an action to the container.
RulesActionContainer::componentProvidesVariables public function Returns an array of provided variable names.
RulesActionContainer::exportToArray protected function Overrides RulesContainerPlugin::exportToArray 1
RulesActionContainer::import public function Applies the given export. Overrides RulesContainerPlugin::import 1
RulesActionContainer::pluginProvidesVariables public function Returns info about variables &#039;provided&#039; by the plugin. Overrides RulesPlugin::pluginProvidesVariables
RulesActionContainer::providesVariables public function Returns info about all variables provided for later evaluated elements. Overrides RulesPlugin::providesVariables 1
RulesContainerPlugin::$children protected property
RulesContainerPlugin::access public function Whether the currently logged in user has access to all configured elements. Overrides RulesPlugin::access 1
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::delete public function Overrides delete to keep the children alive, if possible. Overrides RulesPlugin::delete 1
RulesContainerPlugin::dependencies public function Calculates an array of required modules. Overrides RulesPlugin::dependencies 1
RulesContainerPlugin::destroy public function Removes circular object references so PHP garbage collector can work. Overrides RulesPlugin::destroy 1
RulesContainerPlugin::executeByArgs public function Executes container with the given arguments. Overrides RulesPlugin::executeByArgs 1
RulesContainerPlugin::exportFlat protected function Determines whether the element should be exported in flat style. 1
RulesContainerPlugin::getIterator public function Allows access to the children through the iterator. 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::resetInternalCache public function Resets any internal static caches. Overrides RulesPlugin::resetInternalCache 1
RulesContainerPlugin::setUpVariables protected function Returns info about all variables that have to be setup in the state. Overrides RulesPlugin::setUpVariables
RulesContainerPlugin::sortChildren public function Sorts all child elements by their weight. 1
RulesContainerPlugin::variableInfoAssertions protected function Returns asserted additions to the available variable info. Overrides RulesPlugin::variableInfoAssertions 1
RulesContainerPlugin::__clone public function By default we do a deep clone. Overrides RulesPlugin::__clone 1
RulesContainerPlugin::__sleep public function Overrides RulesPlugin::__sleep 2
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.
RulesLoop::$itemName protected property Overrides RulesExtendable::$itemName
RulesLoop::$listItemInfo protected property
RulesLoop::evaluate public function Evaluate, whereas by default new vars are visible in the parent&#039;s scope. Overrides RulesActionContainer::evaluate
RulesLoop::exportChildren protected function Overrides RulesContainerPlugin::exportChildren
RulesLoop::exportSettings protected function Overrides RulesPlugin::exportSettings
RulesLoop::importChildren protected function Overrides RulesContainerPlugin::importChildren
RulesLoop::importSettings protected function Overrides RulesPlugin::importSettings
RulesLoop::integrityCheck public function Makes sure the plugin is configured right. Overrides RulesContainerPlugin::integrityCheck
RulesLoop::label public function Returns the label of the element. Overrides RulesPlugin::label
RulesLoop::listItemInfo public function
RulesLoop::pluginParameterInfo public function Returns info about parameters needed by the plugin. Overrides RulesPlugin::pluginParameterInfo
RulesLoop::stateVariables protected function Returns available state variables for an element. Overrides RulesContainerPlugin::stateVariables
RulesLoop::__construct public function Overrides RulesActionContainer::__construct
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::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::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::parentElement public function Returns the element&#039;s parent.
RulesPlugin::plugin public function Returns the name of the element&#039;s plugin.
RulesPlugin::pluginInfo public function Returns info about the element&#039;s plugin.
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.