[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  /**
   4   * Configuration definition, defines directives and their defaults.
   5   */
   6  class HTMLPurifier_ConfigSchema {
   7  
   8      /**
   9       * Defaults of the directives and namespaces.
  10       * @note This shares the exact same structure as HTMLPurifier_Config::$conf
  11       */
  12      public $defaults = array();
  13  
  14      /**
  15       * The default property list. Do not edit this property list.
  16       */
  17      public $defaultPlist;
  18  
  19      /**
  20       * Definition of the directives. The structure of this is:
  21       *
  22       *  array(
  23       *      'Namespace' => array(
  24       *          'Directive' => new stdclass(),
  25       *      )
  26       *  )
  27       *
  28       * The stdclass may have the following properties:
  29       *
  30       *  - If isAlias isn't set:
  31       *      - type: Integer type of directive, see HTMLPurifier_VarParser for definitions
  32       *      - allow_null: If set, this directive allows null values
  33       *      - aliases: If set, an associative array of value aliases to real values
  34       *      - allowed: If set, a lookup array of allowed (string) values
  35       *  - If isAlias is set:
  36       *      - namespace: Namespace this directive aliases to
  37       *      - name: Directive name this directive aliases to
  38       *
  39       * In certain degenerate cases, stdclass will actually be an integer. In
  40       * that case, the value is equivalent to an stdclass with the type
  41       * property set to the integer. If the integer is negative, type is
  42       * equal to the absolute value of integer, and allow_null is true.
  43       *
  44       * This class is friendly with HTMLPurifier_Config. If you need introspection
  45       * about the schema, you're better of using the ConfigSchema_Interchange,
  46       * which uses more memory but has much richer information.
  47       */
  48      public $info = array();
  49  
  50      /**
  51       * Application-wide singleton
  52       */
  53      static protected $singleton;
  54  
  55      public function __construct() {
  56          $this->defaultPlist = new HTMLPurifier_PropertyList();
  57      }
  58  
  59      /**
  60       * Unserializes the default ConfigSchema.
  61       */
  62      public static function makeFromSerial() {
  63          return unserialize(file_get_contents(HTMLPURIFIER_PREFIX . '/HTMLPurifier/ConfigSchema/schema.ser'));
  64      }
  65  
  66      /**
  67       * Retrieves an instance of the application-wide configuration definition.
  68       */
  69      public static function instance($prototype = null) {
  70          if ($prototype !== null) {
  71              HTMLPurifier_ConfigSchema::$singleton = $prototype;
  72          } elseif (HTMLPurifier_ConfigSchema::$singleton === null || $prototype === true) {
  73              HTMLPurifier_ConfigSchema::$singleton = HTMLPurifier_ConfigSchema::makeFromSerial();
  74          }
  75          return HTMLPurifier_ConfigSchema::$singleton;
  76      }
  77  
  78      /**
  79       * Defines a directive for configuration
  80       * @warning Will fail of directive's namespace is defined.
  81       * @warning This method's signature is slightly different from the legacy
  82       *          define() static method! Beware!
  83       * @param $namespace Namespace the directive is in
  84       * @param $name Key of directive
  85       * @param $default Default value of directive
  86       * @param $type Allowed type of the directive. See
  87       *      HTMLPurifier_DirectiveDef::$type for allowed values
  88       * @param $allow_null Whether or not to allow null values
  89       */
  90      public function add($namespace, $name, $default, $type, $allow_null) {
  91          $obj = new stdclass();
  92          $obj->type = is_int($type) ? $type : HTMLPurifier_VarParser::$types[$type];
  93          if ($allow_null) $obj->allow_null = true;
  94          $this->info[$namespace][$name] = $obj;
  95          $this->defaults[$namespace][$name] = $default;
  96          $this->defaultPlist->set("$namespace.$name", $default);
  97      }
  98  
  99      /**
 100       * Defines a namespace for directives to be put into.
 101       * @warning This is slightly different from the corresponding static
 102       *          method.
 103       * @param $namespace Namespace's name
 104       */
 105      public function addNamespace($namespace) {
 106          $this->info[$namespace] = array();
 107          $this->defaults[$namespace] = array();
 108      }
 109  
 110      /**
 111       * Defines a directive value alias.
 112       *
 113       * Directive value aliases are convenient for developers because it lets
 114       * them set a directive to several values and get the same result.
 115       * @param $namespace Directive's namespace
 116       * @param $name Name of Directive
 117       * @param $aliases Hash of aliased values to the real alias
 118       */
 119      public function addValueAliases($namespace, $name, $aliases) {
 120          if (!isset($this->info[$namespace][$name]->aliases)) {
 121              $this->info[$namespace][$name]->aliases = array();
 122          }
 123          foreach ($aliases as $alias => $real) {
 124              $this->info[$namespace][$name]->aliases[$alias] = $real;
 125          }
 126      }
 127  
 128      /**
 129       * Defines a set of allowed values for a directive.
 130       * @warning This is slightly different from the corresponding static
 131       *          method definition.
 132       * @param $namespace Namespace of directive
 133       * @param $name Name of directive
 134       * @param $allowed Lookup array of allowed values
 135       */
 136      public function addAllowedValues($namespace, $name, $allowed) {
 137          $this->info[$namespace][$name]->allowed = $allowed;
 138      }
 139  
 140      /**
 141       * Defines a directive alias for backwards compatibility
 142       * @param $namespace
 143       * @param $name Directive that will be aliased
 144       * @param $new_namespace
 145       * @param $new_name Directive that the alias will be to
 146       */
 147      public function addAlias($namespace, $name, $new_namespace, $new_name) {
 148          $obj = new stdclass;
 149          $obj->namespace = $new_namespace;
 150          $obj->name = $new_name;
 151          $obj->isAlias = true;
 152          $this->info[$namespace][$name] = $obj;
 153      }
 154  
 155      /**
 156       * Replaces any stdclass that only has the type property with type integer.
 157       */
 158      public function postProcess() {
 159          foreach ($this->info as $namespace => $info) {
 160              foreach ($info as $directive => $v) {
 161                  if (count((array) $v) == 1) {
 162                      $this->info[$namespace][$directive] = $v->type;
 163                  } elseif (count((array) $v) == 2 && isset($v->allow_null)) {
 164                      $this->info[$namespace][$directive] = -$v->type;
 165                  }
 166              }
 167          }
 168      }
 169  
 170      // DEPRECATED METHODS
 171  
 172      /** @see HTMLPurifier_ConfigSchema->set() */
 173      public static function define($namespace, $name, $default, $type, $description) {
 174          HTMLPurifier_ConfigSchema::deprecated(__METHOD__);
 175          $type_values = explode('/', $type, 2);
 176          $type = $type_values[0];
 177          $modifier = isset($type_values[1]) ? $type_values[1] : false;
 178          $allow_null = ($modifier === 'null');
 179          $def = HTMLPurifier_ConfigSchema::instance();
 180          $def->add($namespace, $name, $default, $type, $allow_null);
 181      }
 182  
 183      /** @see HTMLPurifier_ConfigSchema->addNamespace() */
 184      public static function defineNamespace($namespace, $description) {
 185          HTMLPurifier_ConfigSchema::deprecated(__METHOD__);
 186          $def = HTMLPurifier_ConfigSchema::instance();
 187          $def->addNamespace($namespace);
 188      }
 189  
 190      /** @see HTMLPurifier_ConfigSchema->addValueAliases() */
 191      public static function defineValueAliases($namespace, $name, $aliases) {
 192          HTMLPurifier_ConfigSchema::deprecated(__METHOD__);
 193          $def = HTMLPurifier_ConfigSchema::instance();
 194          $def->addValueAliases($namespace, $name, $aliases);
 195      }
 196  
 197      /** @see HTMLPurifier_ConfigSchema->addAllowedValues() */
 198      public static function defineAllowedValues($namespace, $name, $allowed_values) {
 199          HTMLPurifier_ConfigSchema::deprecated(__METHOD__);
 200          $allowed = array();
 201          foreach ($allowed_values as $value) {
 202              $allowed[$value] = true;
 203          }
 204          $def = HTMLPurifier_ConfigSchema::instance();
 205          $def->addAllowedValues($namespace, $name, $allowed);
 206      }
 207  
 208      /** @see HTMLPurifier_ConfigSchema->addAlias() */
 209      public static function defineAlias($namespace, $name, $new_namespace, $new_name) {
 210          HTMLPurifier_ConfigSchema::deprecated(__METHOD__);
 211          $def = HTMLPurifier_ConfigSchema::instance();
 212          $def->addAlias($namespace, $name, $new_namespace, $new_name);
 213      }
 214  
 215      /** @deprecated, use HTMLPurifier_VarParser->parse() */
 216      public function validate($a, $b, $c = false) {
 217          trigger_error("HTMLPurifier_ConfigSchema->validate deprecated, use HTMLPurifier_VarParser->parse instead", E_USER_NOTICE);
 218          $parser = new HTMLPurifier_VarParser();
 219          return $parser->parse($a, $b, $c);
 220      }
 221  
 222      /**
 223       * Throws an E_USER_NOTICE stating that a method is deprecated.
 224       */
 225      private static function deprecated($method) {
 226          trigger_error("Static HTMLPurifier_ConfigSchema::$method deprecated, use add*() method instead", E_USER_NOTICE);
 227      }
 228  
 229  }
 230  
 231  // vim: et sw=4 sts=4