Collaboration diagram for HTMLPurifier_HTMLModuleManager:

Public Member Functions
	__construct ()
	registerModule ($module, $overload=false)
	Registers a module to the recognized module list, useful for overloading pre-existing modules.
	addModule ($module)
	Adds a module to the current doctype by first registering it, and then tacking it on to the active doctype.
	addPrefix ($prefix)
	Adds a class prefix that registerModule() will use to resolve a string name to a concrete class.
	setup ($config)
	Performs processing on modules, after being called you may use getElement() and getElements()
	processModule ($module)
	Takes a module and adds it to the active module collection, registering it if necessary.
	getElements ()
	Retrieves merged element definitions.
	getElement ($name, $trusted=null)
	Retrieves a single merged element definition.

Data Fields
	$doctypes
	Instance of HTMLPurifier_DoctypeRegistry.
	$doctype
	Instance of current doctype.
	$attrTypes
	Instance of HTMLPurifier_AttrTypes.
	$modules = array()
	Active instances of modules for the specified doctype are indexed, by name, in this array.
	$registeredModules = array()
	Array of recognized HTMLPurifier_Module instances, indexed by module's class name.
	$userModules = array()
	List of extra modules that were added by the user using addModule().
	$elementLookup = array()
	Associative array of element name to list of modules that have definitions for the element; this array is dynamically filled.
	$prefixes = array('HTMLPurifier_HTMLModule_')
	List of prefixes we should use for registering small names.
	$contentSets
	Instance of HTMLPurifier_ContentSets.
	$attrCollections
	Instance of HTMLPurifier_AttrCollections.
	$trusted = false
	If set to true, unsafe elements and attributes will be allowed.

Detailed Description

Definition at line 3 of file HTMLModuleManager.php.

Constructor & Destructor Documentation

HTMLPurifier_HTMLModuleManager::__construct ( )

Definition at line 56 of file HTMLModuleManager.php.

                                  {
        // editable internal objects
        $this->attrTypes = new HTMLPurifier_AttrTypes();
        $this->doctypes  = new HTMLPurifier_DoctypeRegistry();
        // setup basic modules
        $common = array(
            'CommonAttributes', 'Text', 'Hypertext', 'List',
            'Presentation', 'Edit', 'Bdo', 'Tables', 'Image',
            'StyleAttribute',
            // Unsafe:
            'Scripting', 'Object',  'Forms',
            // Sorta legacy, but present in strict:
            'Name',
        );
        $transitional = array('Legacy', 'Target');
        $xml = array('XMLCommonAttributes');
        $non_xml = array('NonXMLCommonAttributes');
        // setup basic doctypes
        $this->doctypes->register(
            'HTML 4.01 Transitional', false,
            array_merge($common, $transitional, $non_xml),
            array('Tidy_Transitional', 'Tidy_Proprietary'),
            array(),
            '-//W3C//DTD HTML 4.01 Transitional//EN',
            'http://www.w3.org/TR/html4/loose.dtd'
        );
        $this->doctypes->register(
            'HTML 4.01 Strict', false,
            array_merge($common, $non_xml),
            array('Tidy_Strict', 'Tidy_Proprietary', 'Tidy_Name'),
            array(),
            '-//W3C//DTD HTML 4.01//EN',
            'http://www.w3.org/TR/html4/strict.dtd'
        );
        $this->doctypes->register(
            'XHTML 1.0 Transitional', true,
            array_merge($common, $transitional, $xml, $non_xml),
            array('Tidy_Transitional', 'Tidy_XHTML', 'Tidy_Proprietary', 'Tidy_Name'),
            array(),
            '-//W3C//DTD XHTML 1.0 Transitional//EN',
            'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'
        );
        $this->doctypes->register(
            'XHTML 1.0 Strict', true,
            array_merge($common, $xml, $non_xml),
            array('Tidy_Strict', 'Tidy_XHTML', 'Tidy_Strict', 'Tidy_Proprietary', 'Tidy_Name'),
            array(),
            '-//W3C//DTD XHTML 1.0 Strict//EN',
            'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
        );
        $this->doctypes->register(
            'XHTML 1.1', true,
            array_merge($common, $xml, array('Ruby')),
            array('Tidy_Strict', 'Tidy_XHTML', 'Tidy_Proprietary', 'Tidy_Strict', 'Tidy_Name'), // Tidy_XHTML1_1
            array(),
            '-//W3C//DTD XHTML 1.1//EN',
            'http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd'
        );
    }

Member Function Documentation

HTMLPurifier_HTMLModuleManager::addModule ( $module )

Adds a module to the current doctype by first registering it, and then tacking it on to the active doctype.

Definition at line 181 of file HTMLModuleManager.php.

References registerModule().

                                       {
        $this->registerModule($module);
        if (is_object($module)) $module = $module->name;
        $this->userModules[] = $module;
    }

Here is the call graph for this function:

HTMLPurifier_HTMLModuleManager::addPrefix ( $prefix )

Adds a class prefix that registerModule() will use to resolve a string name to a concrete class.

Definition at line 191 of file HTMLModuleManager.php.

                                       {
        $this->prefixes[] = $prefix;
    }

HTMLPurifier_HTMLModuleManager::getElement	(	$name,
		$trusted = `null`
	)

Retrieves a single merged element definition.

Parameters

$name	Name of element
$trusted	Boolean trusted overriding parameter: set to true if you want the full version of an element

Returns: Merged HTMLPurifier_ElementDef

Note: You may notice that modules are getting iterated over twice (once in getElements() and once here). This is because

Definition at line 330 of file HTMLModuleManager.php.

References $name, $trusted, and elseif().

Referenced by getElements().

                                                       {
        if (!isset($this->elementLookup[$name])) {
            return false;
        }
        // setup global state variables
        $def = false;
        if ($trusted === null) $trusted = $this->trusted;
        // iterate through each module that has registered itself to this
        // element
        foreach($this->elementLookup[$name] as $module_name) {
            $module = $this->modules[$module_name];
            // refuse to create/merge from a module that is deemed unsafe--
            // pretend the module doesn't exist--when trusted mode is not on.
            if (!$trusted && !$module->safe) {
                continue;
            }
            // clone is used because, ideally speaking, the original
            // definition should not be modified. Usually, this will
            // make no difference, but for consistency's sake
            $new_def = clone $module->info[$name];
            if (!$def && $new_def->standalone) {
                $def = $new_def;
            } elseif ($def) {
                // This will occur even if $new_def is standalone. In practice,
                // this will usually result in a full replacement.
                $def->mergeIn($new_def);
            } else {
                // :TODO:
                // non-standalone definitions that don't have a standalone
                // to merge into could be deferred to the end
                continue;
            }
            // attribute value expansions
            $this->attrCollections->performInclusions($def->attr);
            $this->attrCollections->expandIdentifiers($def->attr, $this->attrTypes);
            // descendants_are_inline, for ChildDef_Chameleon
            if (is_string($def->content_model) &&
                strpos($def->content_model, 'Inline') !== false) {
                if ($name != 'del' && $name != 'ins') {
                    // this is for you, ins/del
                    $def->descendants_are_inline = true;
                }
            }
            $this->contentSets->generateChildDef($def, $module);
        }
        // This can occur if there is a blank definition, but no base to
        // mix it in with
        if (!$def) return false;
        // add information on required attributes
        foreach ($def->attr as $attr_name => $attr_def) {
            if ($attr_def->required) {
                $def->required_attr[] = $attr_name;
            }
        }
        return $def;
    }

Here is the call graph for this function:

Here is the caller graph for this function:

HTMLPurifier_HTMLModuleManager::getElements ( )

Retrieves merged element definitions.

Returns: Array of HTMLPurifier_ElementDef

Definition at line 299 of file HTMLModuleManager.php.

References $n, $name, and getElement().

                                  {
        $elements = array();
        foreach ($this->modules as $module) {
            if (!$this->trusted && !$module->safe) continue;
            foreach ($module->info as $name => $v) {
                if (isset($elements[$name])) continue;
                $elements[$name] = $this->getElement($name);
            }
        }
        // remove dud elements, this happens when an element that
        // appeared to be safe actually wasn't
        foreach ($elements as $n => $v) {
            if ($v === false) unset($elements[$n]);
        }
        return $elements;
    }

Here is the call graph for this function:

HTMLPurifier_HTMLModuleManager::processModule ( $module )

Takes a module and adds it to the active module collection, registering it if necessary.

Definition at line 288 of file HTMLModuleManager.php.

References registerModule().

Referenced by setup().

                                           {
        if (!isset($this->registeredModules[$module]) || is_object($module)) {
            $this->registerModule($module);
        }
        $this->modules[$module] = $this->registeredModules[$module];
    }

Here is the call graph for this function:

Here is the caller graph for this function:

HTMLPurifier_HTMLModuleManager::registerModule	(	$module,
		$overload = `false`
	)

Registers a module to the recognized module list, useful for overloading pre-existing modules.

Parameters

$module	Mixed: string module name, with or without HTMLPurifier_HTMLModule prefix, or instance of subclass of HTMLPurifier_HTMLModule.
$overload	Boolean whether or not to overload previous modules. If this is not set, and you do overload a module, HTML Purifier will complain with a warning.

Note

This function will not call autoload, you must instantiate (and thus invoke) autoload outside the method.

If a string is passed as a module name, different variants will be tested in this order:

Check for HTMLPurifier_HTMLModule_$name
Check all prefixes with $name in order they were added
Check for literal object name
Throw fatal error If your object name collides with an internal class, specify your module manually. All modules must have been included externally: registerModule will not perform inclusions for you!

Definition at line 145 of file HTMLModuleManager.php.

References $ok.

Referenced by addModule(), and processModule().

                                                               {
        if (is_string($module)) {
            // attempt to load the module
            $original_module = $module;
            $ok = false;
            foreach ($this->prefixes as $prefix) {
                $module = $prefix . $original_module;
                if (class_exists($module)) {
                    $ok = true;
                    break;
                }
            }
            if (!$ok) {
                $module = $original_module;
                if (!class_exists($module)) {
                    trigger_error($original_module . ' module does not exist',
                        E_USER_ERROR);
                    return;
                }
            }
            $module = new $module();
        }
        if (empty($module->name)) {
            trigger_error('Module instance of ' . get_class($module) . ' must have name');
            return;
        }
        if (!$overload && isset($this->registeredModules[$module->name])) {
            trigger_error('Overloading ' . $module->name . ' without explicit overload parameter', E_USER_WARNING);
        }
        $this->registeredModules[$module->name] = $module;
    }

Here is the caller graph for this function:

HTMLPurifier_HTMLModuleManager::setup ( $config )

Performs processing on modules, after being called you may use getElement() and getElements()

Parameters

$config Instance of HTMLPurifier_Config

Definition at line 200 of file HTMLModuleManager.php.

References $config, $modules, $n, $name, and processModule().

                                   {
        $this->trusted = $config->get('HTML.Trusted');
        // generate
        $this->doctype = $this->doctypes->make($config);
        $modules = $this->doctype->modules;
        // take out the default modules that aren't allowed
        $lookup = $config->get('HTML.AllowedModules');
        $special_cases = $config->get('HTML.CoreModules');
        if (is_array($lookup)) {
            foreach ($modules as $k => $m) {
                if (isset($special_cases[$m])) continue;
                if (!isset($lookup[$m])) unset($modules[$k]);
            }
        }
        // add proprietary module (this gets special treatment because
        // it is completely removed from doctypes, etc.)
        if ($config->get('HTML.Proprietary')) {
            $modules[] = 'Proprietary';
        }
        // add SafeObject/Safeembed modules
        if ($config->get('HTML.SafeObject')) {
            $modules[] = 'SafeObject';
        }
        if ($config->get('HTML.SafeEmbed')) {
            $modules[] = 'SafeEmbed';
        }
        // merge in custom modules
        $modules = array_merge($modules, $this->userModules);
        foreach ($modules as $module) {
            $this->processModule($module);
            $this->modules[$module]->setup($config);
        }
        foreach ($this->doctype->tidyModules as $module) {
            $this->processModule($module);
            $this->modules[$module]->setup($config);
        }
        // prepare any injectors
        foreach ($this->modules as $module) {
            $n = array();
            foreach ($module->info_injector as $i => $injector) {
                if (!is_object($injector)) {
                    $class = "HTMLPurifier_Injector_$injector";
                    $injector = new $class;
                }
                $n[$injector->name] = $injector;
            }
            $module->info_injector = $n;
        }
        // setup lookup table based on all valid modules
        foreach ($this->modules as $module) {
            foreach ($module->info as $name => $def) {
                if (!isset($this->elementLookup[$name])) {
                    $this->elementLookup[$name] = array();
                }
                $this->elementLookup[$name][] = $module->name;
            }
        }
        // note the different choice
        $this->contentSets = new HTMLPurifier_ContentSets(
            // content set assembly deals with all possible modules,
            // not just ones deemed to be "safe"
            $this->modules
        );
        $this->attrCollections = new HTMLPurifier_AttrCollections(
            $this->attrTypes,
            // there is no way to directly disable a global attribute,
            // but using AllowedAttributes or simply not including
            // the module in your custom doctype should be sufficient
            $this->modules
        );
    }

Here is the call graph for this function:

Field Documentation

HTMLPurifier_HTMLModuleManager::$attrCollections

Instance of HTMLPurifier_AttrCollections.

Definition at line 51 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$attrTypes

Instance of HTMLPurifier_AttrTypes.

Definition at line 19 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$contentSets

Instance of HTMLPurifier_ContentSets.

Definition at line 50 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$doctype

Instance of current doctype.

Definition at line 14 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$doctypes

Instance of HTMLPurifier_DoctypeRegistry.

Definition at line 9 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$elementLookup = array()

Associative array of element name to list of modules that have definitions for the element; this array is dynamically filled.

Definition at line 45 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$modules = array()

Active instances of modules for the specified doctype are indexed, by name, in this array.

Definition at line 25 of file HTMLModuleManager.php.

Referenced by setup().

HTMLPurifier_HTMLModuleManager::$prefixes = array('HTMLPurifier_HTMLModule_')

List of prefixes we should use for registering small names.

Definition at line 48 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$registeredModules = array()

Array of recognized HTMLPurifier_Module instances, indexed by module's class name.

This array is usually lazy loaded, but a user can overload a module by pre-emptively registering it.

Definition at line 32 of file HTMLModuleManager.php.

HTMLPurifier_HTMLModuleManager::$trusted = false

If set to true, unsafe elements and attributes will be allowed.

Definition at line 54 of file HTMLModuleManager.php.

Referenced by getElement().

HTMLPurifier_HTMLModuleManager::$userModules = array()

List of extra modules that were added by the user using addModule().

These get unconditionally merged into the current doctype, whatever it may be.

Definition at line 39 of file HTMLModuleManager.php.

The documentation for this class was generated from the following file:

Services/Html/HtmlPurifier/library/HTMLPurifier/HTMLModuleManager.php

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation