PHP HTMLPurifier_Config::getDefinition方法代码示例

 /**
  * @param HTMLPurifier_Config $config
  * @return void
  */
 public function prepare($config)
 {
     $our_host = $config->getDefinition('URI')->host;
     if ($our_host !== null) {
         $this->ourHostParts = array_reverse(explode('.', $our_host));
     }
 }

 /**
  * @param string $string
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return bool|string
  */
 protected function split($string, $config, $context)
 {
     // really, this twiddle should be lazy loaded
     $name = $config->getDefinition('HTML')->doctype->name;
     if ($name == "XHTML 1.1" || $name == "XHTML 2.0") {
         return parent::split($string, $config, $context);
     } else {
         return preg_split('/\\s+/', $string);
     }
 }

 /**
  * @param HTMLPurifier_Config $config
  * @return bool
  */
 public function prepare($config)
 {
     $def = $config->getDefinition('URI');
     $this->base = $def->base;
     if (is_null($this->base)) {
         trigger_error('URI.MakeAbsolute is being ignored due to lack of ' . 'value for URI.Base configuration', E_USER_WARNING);
         return false;
     }
     $this->base->fragment = null;
     // fragment is invalid for base URI
     $stack = explode('/', $this->base->path);
     array_pop($stack);
     // discard last segment
     $stack = $this->_collapseStack($stack);
     // do pre-parsing
     $this->basePathStack = $stack;
     return true;
 }

 /**
  * Takes CSS (the stuff found in <style>) and cleans it.
  * @warning Requires CSSTidy <http://csstidy.sourceforge.net/>
  * @param string $css CSS styling to clean
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @throws HTMLPurifier_Exception
  * @return string Cleaned CSS
  */
 public function cleanCSS($css, $config, $context)
 {
     // prepare scope
     $scope = $config->get('Filter.ExtractStyleBlocks.Scope');
     if ($scope !== null) {
         $scopes = array_map('trim', explode(',', $scope));
     } else {
         $scopes = array();
     }
     // remove comments from CSS
     $css = trim($css);
     if (strncmp('<!--', $css, 4) === 0) {
         $css = substr($css, 4);
     }
     if (strlen($css) > 3 && substr($css, -3) == '-->') {
         $css = substr($css, 0, -3);
     }
     $css = trim($css);
     set_error_handler('htmlpurifier_filter_extractstyleblocks_muteerrorhandler');
     $this->_tidy->parse($css);
     restore_error_handler();
     $css_definition = $config->getDefinition('CSS');
     $html_definition = $config->getDefinition('HTML');
     $new_css = array();
     foreach ($this->_tidy->css as $k => $decls) {
         // $decls are all CSS declarations inside an @ selector
         $new_decls = array();
         foreach ($decls as $selector => $style) {
             $selector = trim($selector);
             if ($selector === '') {
                 continue;
             }
             // should not happen
             // Parse the selector
             // Here is the relevant part of the CSS grammar:
             //
             // ruleset
             //   : selector [ ',' S* selector ]* '{' ...
             // selector
             //   : simple_selector [ combinator selector | S+ [ combinator? selector ]? ]?
             // combinator
             //   : '+' S*
             //   : '>' S*
             // simple_selector
             //   : element_name [ HASH | class | attrib | pseudo ]*
             //   | [ HASH | class | attrib | pseudo ]+
             // element_name
             //   : IDENT | '*'
             //   ;
             // class
             //   : '.' IDENT
             //   ;
             // attrib
             //   : '[' S* IDENT S* [ [ '=' | INCLUDES | DASHMATCH ] S*
             //     [ IDENT | STRING ] S* ]? ']'
             //   ;
             // pseudo
             //   : ':' [ IDENT | FUNCTION S* [IDENT S*]? ')' ]
             //   ;
             //
             // For reference, here are the relevant tokens:
             //
             // HASH         #{name}
             // IDENT        {ident}
             // INCLUDES     ==
             // DASHMATCH    |=
             // STRING       {string}
             // FUNCTION     {ident}\(
             //
             // And the lexical scanner tokens
             //
             // name         {nmchar}+
             // nmchar       [_a-z0-9-]|{nonascii}|{escape}
             // nonascii     [\240-\377]
             // escape       {unicode}|\\[^\r\n\f0-9a-f]
             // unicode      \\{h}}{1,6}(\r\n|[ \t\r\n\f])?
             // ident        -?{nmstart}{nmchar*}
             // nmstart      [_a-z]|{nonascii}|{escape}
             // string       {string1}|{string2}
             // string1      \"([^\n\r\f\\"]|\\{nl}|{escape})*\"
             // string2      \'([^\n\r\f\\"]|\\{nl}|{escape})*\'
             //
             // We'll implement a subset (in order to reduce attack
             // surface); in particular:
             //
             //      - No Unicode support
             //      - No escapes support
             //      - No string support (by proxy no attrib support)
             //      - element_name is matched against allowed
             //        elements (some people might find this
             //        annoying...)
//.........这里部分代码省略.........

 /**
  * Wraps an HTML fragment in the necessary HTML
  * @param string $html
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return string
  */
 protected function wrapHTML($html, $config, $context)
 {
     $def = $config->getDefinition('HTML');
     $ret = '';
     if (!empty($def->doctype->dtdPublic) || !empty($def->doctype->dtdSystem)) {
         $ret .= '<!DOCTYPE html ';
         if (!empty($def->doctype->dtdPublic)) {
             $ret .= 'PUBLIC "' . $def->doctype->dtdPublic . '" ';
         }
         if (!empty($def->doctype->dtdSystem)) {
             $ret .= '"' . $def->doctype->dtdSystem . '" ';
         }
         $ret .= '>';
     }
     $ret .= '<html><head>';
     $ret .= '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />';
     // No protection if $html contains a stray </div>!
     $ret .= '</head><body>' . $html . '</body></html>';
     return $ret;
 }

 public function test_getDefinition()
 {
     $this->schema->add('Cache.DefinitionImpl', null, 'string', true);
     $config = new HTMLPurifier_Config($this->schema);
     $this->expectException(new HTMLPurifier_Exception("Definition of Crust type not supported"));
     $config->getDefinition('Crust');
 }

 /**
  * Returns true if this URL might be considered a 'local' URL given
  * the current context.  This is true when the host is null, or
  * when it matches the host supplied to the configuration.
  *
  * Note that this does not do any scheme checking, so it is mostly
  * only appropriate for metadata that doesn't care about protocol
  * security.  isBenign is probably what you actually want.
  * @param HTMLPurifier_Config $config
  * @param HTMLPurifier_Context $context
  * @return bool
  */
 public function isLocal($config, $context)
 {
     if ($this->host === null) {
         return true;
     }
     $uri_def = $config->getDefinition('URI');
     if ($uri_def->host === $this->host) {
         return true;
     }
     return false;
 }

 function test_getDefinition()
 {
     $this->schema->addNamespace('Cache', 'Cache stuff');
     $this->schema->add('Cache', 'DefinitionImpl', null, 'string', true);
     $this->schema->addNamespace('Crust', 'Krusty Krabs');
     $config = new HTMLPurifier_Config($this->schema);
     $this->expectException(new HTMLPurifier_Exception("Definition of Crust type not supported"));
     $config->getDefinition('Crust');
 }