PHP HTMLPurifier_Config::get方法代碼示例

 /**
  * @param array $attr
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return array
  */
 public function transform($attr, $config, $context)
 {
     $src = true;
     if (!isset($attr['src'])) {
         if ($config->get('Core.RemoveInvalidImg')) {
             return $attr;
         }
         $attr['src'] = $config->get('Attr.DefaultInvalidImage');
         $src = false;
     }
     if (!isset($attr['alt'])) {
         if ($src) {
             $alt = $config->get('Attr.DefaultImageAlt');
             if ($alt === null) {
                 // truncate if the alt is too long
                 $attr['alt'] = substr(basename($attr['src']), 0, 40);
             } else {
                 $attr['alt'] = $alt;
             }
         } else {
             $attr['alt'] = $config->get('Attr.DefaultInvalidImageAlt');
         }
     }
     return $attr;
 }

 /**
  * @param HTMLPurifier_Config $config
  */
 public function setup($config)
 {
     $max = $config->get('HTML.MaxImgLength');
     $img = $this->addElement('img', 'Inline', 'Empty', 'Common', array('alt*' => 'Text', 'height' => 'Pixels#' . $max, 'width' => 'Pixels#' . $max, 'longdesc' => 'URI', 'src*' => new HTMLPurifier_AttrDef_URI(true)));
     if ($max === null || $config->get('HTML.Trusted')) {
         $img->attr['height'] = $img->attr['width'] = 'Length';
     }
     // kind of strange, but splitting things up would be inefficient
     $img->attr_transform_pre[] = $img->attr_transform_post[] = new HTMLPurifier_AttrTransform_ImgRequired();
 }

 /**
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  */
 public function __construct($config, $context)
 {
     $this->config = $config;
     $this->_scriptFix = $config->get('Output.CommentScriptContents');
     $this->_innerHTMLFix = $config->get('Output.FixInnerHTML');
     $this->_sortAttr = $config->get('Output.SortAttr');
     $this->_flashCompat = $config->get('Output.FlashCompat');
     $this->_def = $config->getHTMLDefinition();
     $this->_xhtml = $this->_def->doctype->xml;
 }

 /**
  * @param HTMLPurifier_Config $config
  * @return bool
  */
 public function prepare($config)
 {
     $this->target = $config->get('URI.' . $this->name);
     $this->parser = new HTMLPurifier_URIParser();
     $this->doEmbed = $config->get('URI.MungeResources');
     $this->secretKey = $config->get('URI.MungeSecretKey');
     if ($this->secretKey && !function_exists('hash_hmac')) {
         throw new Exception("Cannot use %URI.MungeSecretKey without hash_hmac support.");
     }
     return true;
 }

 /**
  * @param array $tokens
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return array
  */
 protected function filter($tokens, $config, $context)
 {
     $allowed = $config->get('Attr.AllowedClasses');
     $forbidden = $config->get('Attr.ForbiddenClasses');
     $ret = array();
     foreach ($tokens as $token) {
         if (($allowed === null || isset($allowed[$token])) && !isset($forbidden[$token]) && !in_array($token, $ret, true)) {
             $ret[] = $token;
         }
     }
     return $ret;
 }

 /**
  * @param string $id
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return bool|string
  */
 public function validate($id, $config, $context)
 {
     if (!$this->selector && !$config->get('Attr.EnableID')) {
         return false;
     }
     $id = trim($id);
     // trim it first
     if ($id === '') {
         return false;
     }
     $prefix = $config->get('Attr.IDPrefix');
     if ($prefix !== '') {
         $prefix .= $config->get('Attr.IDPrefixLocal');
         // prevent re-appending the prefix
         if (strpos($id, $prefix) !== 0) {
             $id = $prefix . $id;
         }
     } elseif ($config->get('Attr.IDPrefixLocal') !== '') {
         trigger_error('%Attr.IDPrefixLocal cannot be used unless ' . '%Attr.IDPrefix is set', E_USER_WARNING);
     }
     if (!$this->selector) {
         $id_accumulator =& $context->get('IDAccumulator');
         if (isset($id_accumulator->ids[$id])) {
             return false;
         }
     }
     // we purposely avoid using regex, hopefully this is faster
     if (ctype_alpha($id)) {
         $result = true;
     } else {
         if (!ctype_alpha(@$id[0])) {
             return false;
         }
         // primitive style of regexps, I suppose
         $trim = trim($id, 'A..Za..z0..9:-._');
         $result = $trim === '';
     }
     $regexp = $config->get('Attr.IDBlacklistRegexp');
     if ($regexp && preg_match($regexp, $id)) {
         return false;
     }
     if (!$this->selector && $result) {
         $id_accumulator->add($id);
     }
     // if no change was made to the ID, return the result
     // else, return the new id if stripping whitespace made it
     //     valid, or return false.
     return $result ? $id : false;
 }

 /**
  * Public interface for validating components of a URI.  Performs a
  * bunch of default actions. Don't overload this method.
  * @param HTMLPurifier_URI $uri Reference to a HTMLPurifier_URI object
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return bool success or failure
  */
 public function validate(&$uri, $config, $context)
 {
     if ($this->default_port == $uri->port) {
         $uri->port = null;
     }
     // kludge: browsers do funny things when the scheme but not the
     // authority is set
     if (!$this->may_omit_host && (!is_null($uri->scheme) && ($uri->host === '' || is_null($uri->host))) || is_null($uri->scheme) && $uri->host === '') {
         do {
             if (is_null($uri->scheme)) {
                 if (substr($uri->path, 0, 2) != '//') {
                     $uri->host = null;
                     break;
                 }
                 // URI is '////path', so we cannot nullify the
                 // host to preserve semantics.  Try expanding the
                 // hostname instead (fall through)
             }
             // first see if we can manually insert a hostname
             $host = $config->get('URI.Host');
             if (!is_null($host)) {
                 $uri->host = $host;
             } else {
                 // we can't do anything sensible, reject the URL.
                 return false;
             }
         } while (false);
     }
     return $this->doValidate($uri, $config, $context);
 }

 /**
  * @param string $string
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return bool|string
  */
 public function validate($string, $config, $context)
 {
     static $colors = null;
     if ($colors === null) {
         $colors = $config->get('Core.ColorKeywords');
     }
     $string = trim($string);
     if (empty($string)) {
         return false;
     }
     $lower = strtolower($string);
     if (isset($colors[$lower])) {
         return $colors[$lower];
     }
     if ($string[0] === '#') {
         $hex = substr($string, 1);
     } else {
         $hex = $string;
     }
     $length = strlen($hex);
     if ($length !== 3 && $length !== 6) {
         return false;
     }
     if (!ctype_xdigit($hex)) {
         return false;
     }
     if ($length === 3) {
         $hex = $hex[0] . $hex[0] . $hex[1] . $hex[1] . $hex[2] . $hex[2];
     }
     return "#{$hex}";
 }

 /**
  * @param HTMLPurifier_Config $config
  */
 public function setup($config)
 {
     if ($config->get('HTML.SafeIframe')) {
         $this->safe = true;
     }
     $this->addElement('iframe', 'Inline', 'Flow', 'Common', array('src' => 'URI#embedded', 'width' => 'Length', 'height' => 'Length', 'name' => 'ID', 'scrolling' => 'Enum#yes,no,auto', 'frameborder' => 'Enum#0,1', 'longdesc' => 'URI', 'marginheight' => 'Pixels', 'marginwidth' => 'Pixels'));
 }

 /**
  * Factory method that creates a cache object based on configuration
  * @param string $type Name of definitions handled by cache
  * @param HTMLPurifier_Config $config Config instance
  * @return mixed
  */
 public function create($type, $config)
 {
     $method = $config->get('Cache.DefinitionImpl');
     if ($method === null) {
         return new HTMLPurifier_DefinitionCache_Null($type);
     }
     if (!empty($this->caches[$method][$type])) {
         return $this->caches[$method][$type];
     }
     if (isset($this->implementations[$method]) && class_exists($class = $this->implementations[$method], false)) {
         $cache = new $class($type);
     } else {
         if ($method != 'Serializer') {
             trigger_error("Unrecognized DefinitionCache {$method}, using Serializer instead", E_USER_WARNING);
         }
         $cache = new HTMLPurifier_DefinitionCache_Serializer($type);
     }
     foreach ($this->decorators as $decorator) {
         $new_cache = $decorator->decorate($cache);
         // prevent infinite recursion in PHP 4
         unset($cache);
         $cache = $new_cache;
     }
     $this->caches[$method][$type] = $cache;
     return $this->caches[$method][$type];
 }

 /**
  * @param string $string
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return bool|string
  */
 public function validate($string, $config, $context)
 {
     if ($this->valid_values === false) {
         $this->valid_values = $config->get('Attr.AllowedFrameTargets');
     }
     return parent::validate($string, $config, $context);
 }

 /**
  * @param HTMLPurifier_URI $uri
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return bool
  */
 public function filter(&$uri, $config, $context)
 {
     // check if filter not applicable
     if (!$config->get('HTML.SafeIframe')) {
         return true;
     }
     // check if the filter should actually trigger
     if (!$context->get('EmbeddedURI', true)) {
         return true;
     }
     $token = $context->get('CurrentToken', true);
     if (!($token && $token->name == 'iframe')) {
         return true;
     }
     // check if we actually have some whitelists enabled
     if ($this->regexp === null) {
         return false;
     }
     // actually check the whitelists
     if (!preg_match($this->regexp, $uri->toString())) {
         return false;
     }
     // Make sure that if we're an HTTPS site, the iframe is also HTTPS
     if (is_https() && $uri->scheme == 'http') {
         // Convert it to a protocol-relative URL
         $uri->scheme = null;
     }
     return $uri;
 }

 /**
  * @param array $attr
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return array
  */
 public function transform($attr, $config, $context)
 {
     if (isset($attr['dir'])) {
         return $attr;
     }
     $attr['dir'] = $config->get('Attr.DefaultTextDir');
     return $attr;
 }

 /**
  * @param HTMLPurifier_Config $config
  */
 public function setup($config)
 {
     // These definitions are not intrinsically safe: the attribute transforms
     // are a vital part of ensuring safety.
     $allowed = $config->get('HTML.SafeScripting');
     $script = $this->addElement('script', 'Inline', 'Empty', null, array('type' => 'Enum#application/javascript', 'src*' => new HTMLPurifier_AttrDef_Enum(array_keys($allowed))));
     $script->attr_transform_pre[] = $script->attr_transform_post[] = new HTMLPurifier_AttrTransform_ScriptRequired();
 }

 /**
  * @param HTMLPurifier_Config $config
  */
 public function setup($config)
 {
     $elements = array('a', 'applet', 'form', 'frame', 'iframe', 'img', 'map');
     foreach ($elements as $name) {
         $element = $this->addBlankElement($name);
         $element->attr['name'] = 'CDATA';
         if (!$config->get('HTML.Attr.Name.UseCDATA')) {
             $element->attr_transform_post[] = new HTMLPurifier_AttrTransform_NameSync();
         }
     }
 }