Dolibarr / dolibarr

htdocs/includes/sabre/sabre/xml/lib/Element/Base.php

Indentation +58 added lines, -58 removed lines

@@ -19,66 +19,66 @@
  */
 class Base implements Xml\Element
 {
-    /**
-     * PHP value to serialize.
-     *
-     * @var mixed
-     */
-    protected $value;
+	/**
+	 * PHP value to serialize.
+	 *
+	 * @var mixed
+	 */
+	protected $value;
 
-    /**
-     * Constructor.
-     */
-    public function __construct($value = null)
-    {
-        $this->value = $value;
-    }
+	/**
+	 * Constructor.
+	 */
+	public function __construct($value = null)
+	{
+		$this->value = $value;
+	}
 
-    /**
-     * The xmlSerialize method is called during xml writing.
-     *
-     * Use the $writer argument to write its own xml serialization.
-     *
-     * An important note: do _not_ create a parent element. Any element
-     * implementing XmlSerializable should only ever write what's considered
-     * its 'inner xml'.
-     *
-     * The parent of the current element is responsible for writing a
-     * containing element.
-     *
-     * This allows serializers to be re-used for different element names.
-     *
-     * If you are opening new elements, you must also close them again.
-     */
-    public function xmlSerialize(Xml\Writer $writer)
-    {
-        $writer->write($this->value);
-    }
+	/**
+	 * The xmlSerialize method is called during xml writing.
+	 *
+	 * Use the $writer argument to write its own xml serialization.
+	 *
+	 * An important note: do _not_ create a parent element. Any element
+	 * implementing XmlSerializable should only ever write what's considered
+	 * its 'inner xml'.
+	 *
+	 * The parent of the current element is responsible for writing a
+	 * containing element.
+	 *
+	 * This allows serializers to be re-used for different element names.
+	 *
+	 * If you are opening new elements, you must also close them again.
+	 */
+	public function xmlSerialize(Xml\Writer $writer)
+	{
+		$writer->write($this->value);
+	}
 
-    /**
-     * The deserialize method is called during xml parsing.
-     *
-     * This method is called statically, this is because in theory this method
-     * may be used as a type of constructor, or factory method.
-     *
-     * Often you want to return an instance of the current class, but you are
-     * free to return other data as well.
-     *
-     * Important note 2: You are responsible for advancing the reader to the
-     * next element. Not doing anything will result in a never-ending loop.
-     *
-     * If you just want to skip parsing for this element altogether, you can
-     * just call $reader->next();
-     *
-     * $reader->parseInnerTree() will parse the entire sub-tree, and advance to
-     * the next element.
-     *
-     * @return mixed
-     */
-    public static function xmlDeserialize(Xml\Reader $reader)
-    {
-        $subTree = $reader->parseInnerTree();
+	/**
+	 * The deserialize method is called during xml parsing.
+	 *
+	 * This method is called statically, this is because in theory this method
+	 * may be used as a type of constructor, or factory method.
+	 *
+	 * Often you want to return an instance of the current class, but you are
+	 * free to return other data as well.
+	 *
+	 * Important note 2: You are responsible for advancing the reader to the
+	 * next element. Not doing anything will result in a never-ending loop.
+	 *
+	 * If you just want to skip parsing for this element altogether, you can
+	 * just call $reader->next();
+	 *
+	 * $reader->parseInnerTree() will parse the entire sub-tree, and advance to
+	 * the next element.
+	 *
+	 * @return mixed
+	 */
+	public static function xmlDeserialize(Xml\Reader $reader)
+	{
+		$subTree = $reader->parseInnerTree();
 
-        return $subTree;
-    }
+		return $subTree;
+	}
 }

htdocs/includes/sabre/sabre/xml/lib/LibXMLException.php

Indentation +26 added lines, -26 removed lines

@@ -18,32 +18,32 @@
  */
 class LibXMLException extends ParseException
 {
-    /**
-     * The error list.
-     *
-     * @var \LibXMLError[]
-     */
-    protected $errors;
+	/**
+	 * The error list.
+	 *
+	 * @var \LibXMLError[]
+	 */
+	protected $errors;
 
-    /**
-     * Creates the exception.
-     *
-     * You should pass a list of LibXMLError objects in its constructor.
-     *
-     * @param LibXMLError[] $errors
-     * @param Throwable     $previousException
-     */
-    public function __construct(array $errors, int $code = 0, Throwable $previousException = null)
-    {
-        $this->errors = $errors;
-        parent::__construct($errors[0]->message.' on line '.$errors[0]->line.', column '.$errors[0]->column, $code, $previousException);
-    }
+	/**
+	 * Creates the exception.
+	 *
+	 * You should pass a list of LibXMLError objects in its constructor.
+	 *
+	 * @param LibXMLError[] $errors
+	 * @param Throwable     $previousException
+	 */
+	public function __construct(array $errors, int $code = 0, Throwable $previousException = null)
+	{
+		$this->errors = $errors;
+		parent::__construct($errors[0]->message.' on line '.$errors[0]->line.', column '.$errors[0]->column, $code, $previousException);
+	}
 
-    /**
-     * Returns the LibXML errors.
-     */
-    public function getErrors(): array
-    {
-        return $this->errors;
-    }
+	/**
+	 * Returns the LibXML errors.
+	 */
+	public function getErrors(): array
+	{
+		return $this->errors;
+	}
 }

htdocs/includes/sabre/sabre/xml/lib/Writer.php

Indentation +207 added lines, -207 removed lines

@@ -32,226 +32,226 @@
  */
 class Writer extends XMLWriter
 {
-    use ContextStackTrait;
+	use ContextStackTrait;
 
-    /**
-     * Any namespace that the writer is asked to write, will be added here.
-     *
-     * Any of these elements will get a new namespace definition *every single
-     * time* they are used, but this array allows the writer to make sure that
-     * the prefixes are consistent anyway.
-     *
-     * @var array
-     */
-    protected $adhocNamespaces = [];
+	/**
+	 * Any namespace that the writer is asked to write, will be added here.
+	 *
+	 * Any of these elements will get a new namespace definition *every single
+	 * time* they are used, but this array allows the writer to make sure that
+	 * the prefixes are consistent anyway.
+	 *
+	 * @var array
+	 */
+	protected $adhocNamespaces = [];
 
-    /**
-     * When the first element is written, this flag is set to true.
-     *
-     * This ensures that the namespaces in the namespaces map are only written
-     * once.
-     *
-     * @var bool
-     */
-    protected $namespacesWritten = false;
+	/**
+	 * When the first element is written, this flag is set to true.
+	 *
+	 * This ensures that the namespaces in the namespaces map are only written
+	 * once.
+	 *
+	 * @var bool
+	 */
+	protected $namespacesWritten = false;
 
-    /**
-     * Writes a value to the output stream.
-     *
-     * The following values are supported:
-     *   1. Scalar values will be written as-is, as text.
-     *   2. Null values will be skipped (resulting in a short xml tag).
-     *   3. If a value is an instance of an Element class, writing will be
-     *      delegated to the object.
-     *   4. If a value is an array, two formats are supported.
-     *
-     *  Array format 1:
-     *  [
-     *    "{namespace}name1" => "..",
-     *    "{namespace}name2" => "..",
-     *  ]
-     *
-     *  One element will be created for each key in this array. The values of
-     *  this array support any format this method supports (this method is
-     *  called recursively).
-     *
-     *  Array format 2:
-     *
-     *  [
-     *    [
-     *      "name" => "{namespace}name1"
-     *      "value" => "..",
-     *      "attributes" => [
-     *          "attr" => "attribute value",
-     *      ]
-     *    ],
-     *    [
-     *      "name" => "{namespace}name1"
-     *      "value" => "..",
-     *      "attributes" => [
-     *          "attr" => "attribute value",
-     *      ]
-     *    ]
-     * ]
-     *
-     * @param mixed $value
-     */
-    public function write($value)
-    {
-        Serializer\standardSerializer($this, $value);
-    }
+	/**
+	 * Writes a value to the output stream.
+	 *
+	 * The following values are supported:
+	 *   1. Scalar values will be written as-is, as text.
+	 *   2. Null values will be skipped (resulting in a short xml tag).
+	 *   3. If a value is an instance of an Element class, writing will be
+	 *      delegated to the object.
+	 *   4. If a value is an array, two formats are supported.
+	 *
+	 *  Array format 1:
+	 *  [
+	 *    "{namespace}name1" => "..",
+	 *    "{namespace}name2" => "..",
+	 *  ]
+	 *
+	 *  One element will be created for each key in this array. The values of
+	 *  this array support any format this method supports (this method is
+	 *  called recursively).
+	 *
+	 *  Array format 2:
+	 *
+	 *  [
+	 *    [
+	 *      "name" => "{namespace}name1"
+	 *      "value" => "..",
+	 *      "attributes" => [
+	 *          "attr" => "attribute value",
+	 *      ]
+	 *    ],
+	 *    [
+	 *      "name" => "{namespace}name1"
+	 *      "value" => "..",
+	 *      "attributes" => [
+	 *          "attr" => "attribute value",
+	 *      ]
+	 *    ]
+	 * ]
+	 *
+	 * @param mixed $value
+	 */
+	public function write($value)
+	{
+		Serializer\standardSerializer($this, $value);
+	}
 
-    /**
-     * Opens a new element.
-     *
-     * You can either just use a local elementname, or you can use clark-
-     * notation to start a new element.
-     *
-     * Example:
-     *
-     *     $writer->startElement('{http://www.w3.org/2005/Atom}entry');
-     *
-     * Would result in something like:
-     *
-     *     <entry xmlns="http://w3.org/2005/Atom">
-     *
-     * Note: this function doesn't have the string typehint, because PHP's
-     * XMLWriter::startElement doesn't either.
-     *
-     * @param string $name
-     */
-    public function startElement($name): bool
-    {
-        if ('{' === $name[0]) {
-            list($namespace, $localName) =
-                Service::parseClarkNotation($name);
+	/**
+	 * Opens a new element.
+	 *
+	 * You can either just use a local elementname, or you can use clark-
+	 * notation to start a new element.
+	 *
+	 * Example:
+	 *
+	 *     $writer->startElement('{http://www.w3.org/2005/Atom}entry');
+	 *
+	 * Would result in something like:
+	 *
+	 *     <entry xmlns="http://w3.org/2005/Atom">
+	 *
+	 * Note: this function doesn't have the string typehint, because PHP's
+	 * XMLWriter::startElement doesn't either.
+	 *
+	 * @param string $name
+	 */
+	public function startElement($name): bool
+	{
+		if ('{' === $name[0]) {
+			list($namespace, $localName) =
+				Service::parseClarkNotation($name);
 
-            if (array_key_exists($namespace, $this->namespaceMap)) {
-                $result = $this->startElementNS(
-                    '' === $this->namespaceMap[$namespace] ? null : $this->namespaceMap[$namespace],
-                    $localName,
-                    null
-                );
-            } else {
-                // An empty namespace means it's the global namespace. This is
-                // allowed, but it mustn't get a prefix.
-                if ('' === $namespace || null === $namespace) {
-                    $result = $this->startElement($localName);
-                    $this->writeAttribute('xmlns', '');
-                } else {
-                    if (!isset($this->adhocNamespaces[$namespace])) {
-                        $this->adhocNamespaces[$namespace] = 'x'.(count($this->adhocNamespaces) + 1);
-                    }
-                    $result = $this->startElementNS($this->adhocNamespaces[$namespace], $localName, $namespace);
-                }
-            }
-        } else {
-            $result = parent::startElement($name);
-        }
+			if (array_key_exists($namespace, $this->namespaceMap)) {
+				$result = $this->startElementNS(
+					'' === $this->namespaceMap[$namespace] ? null : $this->namespaceMap[$namespace],
+					$localName,
+					null
+				);
+			} else {
+				// An empty namespace means it's the global namespace. This is
+				// allowed, but it mustn't get a prefix.
+				if ('' === $namespace || null === $namespace) {
+					$result = $this->startElement($localName);
+					$this->writeAttribute('xmlns', '');
+				} else {
+					if (!isset($this->adhocNamespaces[$namespace])) {
+						$this->adhocNamespaces[$namespace] = 'x'.(count($this->adhocNamespaces) + 1);
+					}
+					$result = $this->startElementNS($this->adhocNamespaces[$namespace], $localName, $namespace);
+				}
+			}
+		} else {
+			$result = parent::startElement($name);
+		}
 
-        if (!$this->namespacesWritten) {
-            foreach ($this->namespaceMap as $namespace => $prefix) {
-                $this->writeAttribute(($prefix ? 'xmlns:'.$prefix : 'xmlns'), $namespace);
-            }
-            $this->namespacesWritten = true;
-        }
+		if (!$this->namespacesWritten) {
+			foreach ($this->namespaceMap as $namespace => $prefix) {
+				$this->writeAttribute(($prefix ? 'xmlns:'.$prefix : 'xmlns'), $namespace);
+			}
+			$this->namespacesWritten = true;
+		}
 
-        return $result;
-    }
+		return $result;
+	}
 
-    /**
-     * Write a full element tag and it's contents.
-     *
-     * This method automatically closes the element as well.
-     *
-     * The element name may be specified in clark-notation.
-     *
-     * Examples:
-     *
-     *    $writer->writeElement('{http://www.w3.org/2005/Atom}author',null);
-     *    becomes:
-     *    <author xmlns="http://www.w3.org/2005" />
-     *
-     *    $writer->writeElement('{http://www.w3.org/2005/Atom}author', [
-     *       '{http://www.w3.org/2005/Atom}name' => 'Evert Pot',
-     *    ]);
-     *    becomes:
-     *    <author xmlns="http://www.w3.org/2005" /><name>Evert Pot</name></author>
-     *
-     * Note: this function doesn't have the string typehint, because PHP's
-     * XMLWriter::startElement doesn't either.
-     *
-     * @param array|string|object|null $content
-     */
-    public function writeElement($name, $content = null): bool
-    {
-        $this->startElement($name);
-        if (!is_null($content)) {
-            $this->write($content);
-        }
-        $this->endElement();
+	/**
+	 * Write a full element tag and it's contents.
+	 *
+	 * This method automatically closes the element as well.
+	 *
+	 * The element name may be specified in clark-notation.
+	 *
+	 * Examples:
+	 *
+	 *    $writer->writeElement('{http://www.w3.org/2005/Atom}author',null);
+	 *    becomes:
+	 *    <author xmlns="http://www.w3.org/2005" />
+	 *
+	 *    $writer->writeElement('{http://www.w3.org/2005/Atom}author', [
+	 *       '{http://www.w3.org/2005/Atom}name' => 'Evert Pot',
+	 *    ]);
+	 *    becomes:
+	 *    <author xmlns="http://www.w3.org/2005" /><name>Evert Pot</name></author>
+	 *
+	 * Note: this function doesn't have the string typehint, because PHP's
+	 * XMLWriter::startElement doesn't either.
+	 *
+	 * @param array|string|object|null $content
+	 */
+	public function writeElement($name, $content = null): bool
+	{
+		$this->startElement($name);
+		if (!is_null($content)) {
+			$this->write($content);
+		}
+		$this->endElement();
 
-        return true;
-    }
+		return true;
+	}
 
-    /**
-     * Writes a list of attributes.
-     *
-     * Attributes are specified as a key->value array.
-     *
-     * The key is an attribute name. If the key is a 'localName', the current
-     * xml namespace is assumed. If it's a 'clark notation key', this namespace
-     * will be used instead.
-     */
-    public function writeAttributes(array $attributes)
-    {
-        foreach ($attributes as $name => $value) {
-            $this->writeAttribute($name, $value);
-        }
-    }
+	/**
+	 * Writes a list of attributes.
+	 *
+	 * Attributes are specified as a key->value array.
+	 *
+	 * The key is an attribute name. If the key is a 'localName', the current
+	 * xml namespace is assumed. If it's a 'clark notation key', this namespace
+	 * will be used instead.
+	 */
+	public function writeAttributes(array $attributes)
+	{
+		foreach ($attributes as $name => $value) {
+			$this->writeAttribute($name, $value);
+		}
+	}
 
-    /**
-     * Writes a new attribute.
-     *
-     * The name may be specified in clark-notation.
-     *
-     * Returns true when successful.
-     *
-     * Note: this function doesn't have typehints, because for some reason
-     * PHP's XMLWriter::writeAttribute doesn't either.
-     *
-     * @param string $name
-     * @param string $value
-     */
-    public function writeAttribute($name, $value): bool
-    {
-        if ('{' !== $name[0]) {
-            return parent::writeAttribute($name, $value);
-        }
+	/**
+	 * Writes a new attribute.
+	 *
+	 * The name may be specified in clark-notation.
+	 *
+	 * Returns true when successful.
+	 *
+	 * Note: this function doesn't have typehints, because for some reason
+	 * PHP's XMLWriter::writeAttribute doesn't either.
+	 *
+	 * @param string $name
+	 * @param string $value
+	 */
+	public function writeAttribute($name, $value): bool
+	{
+		if ('{' !== $name[0]) {
+			return parent::writeAttribute($name, $value);
+		}
 
-        list(
-            $namespace,
-            $localName
-        ) = Service::parseClarkNotation($name);
+		list(
+			$namespace,
+			$localName
+		) = Service::parseClarkNotation($name);
 
-        if (array_key_exists($namespace, $this->namespaceMap)) {
-            // It's an attribute with a namespace we know
-            return $this->writeAttribute(
-                $this->namespaceMap[$namespace].':'.$localName,
-                $value
-            );
-        }
+		if (array_key_exists($namespace, $this->namespaceMap)) {
+			// It's an attribute with a namespace we know
+			return $this->writeAttribute(
+				$this->namespaceMap[$namespace].':'.$localName,
+				$value
+			);
+		}
 
-        // We don't know the namespace, we must add it in-line
-        if (!isset($this->adhocNamespaces[$namespace])) {
-            $this->adhocNamespaces[$namespace] = 'x'.(count($this->adhocNamespaces) + 1);
-        }
+		// We don't know the namespace, we must add it in-line
+		if (!isset($this->adhocNamespaces[$namespace])) {
+			$this->adhocNamespaces[$namespace] = 'x'.(count($this->adhocNamespaces) + 1);
+		}
 
-        return $this->writeAttributeNS(
-            $this->adhocNamespaces[$namespace],
-            $localName,
-            $namespace,
-            $value
-        );
-    }
+		return $this->writeAttributeNS(
+			$this->adhocNamespaces[$namespace],
+			$localName,
+			$namespace,
+			$value
+		);
+	}
 }

htdocs/includes/sabre/sabre/xml/lib/Reader.php

Indentation +283 added lines, -283 removed lines

@@ -21,287 +21,287 @@
  */
 class Reader extends XMLReader
 {
-    use ContextStackTrait;
-
-    /**
-     * Returns the current nodename in clark-notation.
-     *
-     * For example: "{http://www.w3.org/2005/Atom}feed".
-     * Or if no namespace is defined: "{}feed".
-     *
-     * This method returns null if we're not currently on an element.
-     *
-     * @return string|null
-     */
-    public function getClark()
-    {
-        if (!$this->localName) {
-            return null;
-        }
-
-        return '{'.$this->namespaceURI.'}'.$this->localName;
-    }
-
-    /**
-     * Reads the entire document.
-     *
-     * This function returns an array with the following three elements:
-     *    * name - The root element name.
-     *    * value - The value for the root element.
-     *    * attributes - An array of attributes.
-     *
-     * This function will also disable the standard libxml error handler (which
-     * usually just results in PHP errors), and throw exceptions instead.
-     */
-    public function parse(): array
-    {
-        $previousEntityState = null;
-        $shouldCallLibxmlDisableEntityLoader = (\LIBXML_VERSION < 20900);
-        if ($shouldCallLibxmlDisableEntityLoader) {
-            $previousEntityState = libxml_disable_entity_loader(true);
-        }
-        $previousSetting = libxml_use_internal_errors(true);
-
-        try {
-            while (self::ELEMENT !== $this->nodeType) {
-                if (!$this->read()) {
-                    $errors = libxml_get_errors();
-                    libxml_clear_errors();
-                    if ($errors) {
-                        throw new LibXMLException($errors);
-                    }
-                }
-            }
-            $result = $this->parseCurrentElement();
-
-            // last line of defense in case errors did occur above
-            $errors = libxml_get_errors();
-            libxml_clear_errors();
-            if ($errors) {
-                throw new LibXMLException($errors);
-            }
-        } finally {
-            libxml_use_internal_errors($previousSetting);
-            if ($shouldCallLibxmlDisableEntityLoader) {
-                libxml_disable_entity_loader($previousEntityState);
-            }
-        }
-
-        return $result;
-    }
-
-    /**
-     * parseGetElements parses everything in the current sub-tree,
-     * and returns an array of elements.
-     *
-     * Each element has a 'name', 'value' and 'attributes' key.
-     *
-     * If the element didn't contain sub-elements, an empty array is always
-     * returned. If there was any text inside the element, it will be
-     * discarded.
-     *
-     * If the $elementMap argument is specified, the existing elementMap will
-     * be overridden while parsing the tree, and restored after this process.
-     */
-    public function parseGetElements(array $elementMap = null): array
-    {
-        $result = $this->parseInnerTree($elementMap);
-        if (!is_array($result)) {
-            return [];
-        }
-
-        return $result;
-    }
-
-    /**
-     * Parses all elements below the current element.
-     *
-     * This method will return a string if this was a text-node, or an array if
-     * there were sub-elements.
-     *
-     * If there's both text and sub-elements, the text will be discarded.
-     *
-     * If the $elementMap argument is specified, the existing elementMap will
-     * be overridden while parsing the tree, and restored after this process.
-     *
-     * @return array|string|null
-     */
-    public function parseInnerTree(array $elementMap = null)
-    {
-        $text = null;
-        $elements = [];
-
-        if (self::ELEMENT === $this->nodeType && $this->isEmptyElement) {
-            // Easy!
-            $this->next();
-
-            return null;
-        }
-
-        if (!is_null($elementMap)) {
-            $this->pushContext();
-            $this->elementMap = $elementMap;
-        }
-
-        try {
-            if (!$this->read()) {
-                $errors = libxml_get_errors();
-                libxml_clear_errors();
-                if ($errors) {
-                    throw new LibXMLException($errors);
-                }
-                throw new ParseException('This should never happen (famous last words)');
-            }
-
-            $keepOnParsing = true;
-
-            while ($keepOnParsing) {
-                if (!$this->isValid()) {
-                    $errors = libxml_get_errors();
-
-                    if ($errors) {
-                        libxml_clear_errors();
-                        throw new LibXMLException($errors);
-                    }
-                }
-
-                switch ($this->nodeType) {
-                    case self::ELEMENT:
-                        $elements[] = $this->parseCurrentElement();
-                        break;
-                    case self::TEXT:
-                    case self::CDATA:
-                        $text .= $this->value;
-                        $this->read();
-                        break;
-                    case self::END_ELEMENT:
-                        // Ensuring we are moving the cursor after the end element.
-                        $this->read();
-                        $keepOnParsing = false;
-                        break;
-                    case self::NONE:
-                        throw new ParseException('We hit the end of the document prematurely. This likely means that some parser "eats" too many elements. Do not attempt to continue parsing.');
-                    default:
-                        // Advance to the next element
-                        $this->read();
-                        break;
-                }
-            }
-        } finally {
-            if (!is_null($elementMap)) {
-                $this->popContext();
-            }
-        }
-
-        return $elements ? $elements : $text;
-    }
-
-    /**
-     * Reads all text below the current element, and returns this as a string.
-     */
-    public function readText(): string
-    {
-        $result = '';
-        $previousDepth = $this->depth;
-
-        while ($this->read() && $this->depth != $previousDepth) {
-            if (in_array($this->nodeType, [XMLReader::TEXT, XMLReader::CDATA, XMLReader::WHITESPACE])) {
-                $result .= $this->value;
-            }
-        }
-
-        return $result;
-    }
-
-    /**
-     * Parses the current XML element.
-     *
-     * This method returns arn array with 3 properties:
-     *   * name - A clark-notation XML element name.
-     *   * value - The parsed value.
-     *   * attributes - A key-value list of attributes.
-     */
-    public function parseCurrentElement(): array
-    {
-        $name = $this->getClark();
-
-        $attributes = [];
-
-        if ($this->hasAttributes) {
-            $attributes = $this->parseAttributes();
-        }
-
-        $value = call_user_func(
-            $this->getDeserializerForElementName((string) $name),
-            $this
-        );
-
-        return [
-            'name' => $name,
-            'value' => $value,
-            'attributes' => $attributes,
-        ];
-    }
-
-    /**
-     * Grabs all the attributes from the current element, and returns them as a
-     * key-value array.
-     *
-     * If the attributes are part of the same namespace, they will simply be
-     * short keys. If they are defined on a different namespace, the attribute
-     * name will be returned in clark-notation.
-     */
-    public function parseAttributes(): array
-    {
-        $attributes = [];
-
-        while ($this->moveToNextAttribute()) {
-            if ($this->namespaceURI) {
-                // Ignoring 'xmlns', it doesn't make any sense.
-                if ('http://www.w3.org/2000/xmlns/' === $this->namespaceURI) {
-                    continue;
-                }
-
-                $name = $this->getClark();
-                $attributes[$name] = $this->value;
-            } else {
-                $attributes[$this->localName] = $this->value;
-            }
-        }
-        $this->moveToElement();
-
-        return $attributes;
-    }
-
-    /**
-     * Returns the function that should be used to parse the element identified
-     * by its clark-notation name.
-     */
-    public function getDeserializerForElementName(string $name): callable
-    {
-        if (!array_key_exists($name, $this->elementMap)) {
-            if ('{}' == substr($name, 0, 2) && array_key_exists(substr($name, 2), $this->elementMap)) {
-                $name = substr($name, 2);
-            } else {
-                return ['Sabre\\Xml\\Element\\Base', 'xmlDeserialize'];
-            }
-        }
-
-        $deserializer = $this->elementMap[$name];
-        if (is_subclass_of($deserializer, 'Sabre\\Xml\\XmlDeserializable')) {
-            return [$deserializer, 'xmlDeserialize'];
-        }
-
-        if (is_callable($deserializer)) {
-            return $deserializer;
-        }
-
-        $type = gettype($deserializer);
-        if ('string' === $type) {
-            $type .= ' ('.$deserializer.')';
-        } elseif ('object' === $type) {
-            $type .= ' ('.get_class($deserializer).')';
-        }
-        throw new \LogicException('Could not use this type as a deserializer: '.$type.' for element: '.$name);
-    }
+	use ContextStackTrait;
+
+	/**
+	 * Returns the current nodename in clark-notation.
+	 *
+	 * For example: "{http://www.w3.org/2005/Atom}feed".
+	 * Or if no namespace is defined: "{}feed".
+	 *
+	 * This method returns null if we're not currently on an element.
+	 *
+	 * @return string|null
+	 */
+	public function getClark()
+	{
+		if (!$this->localName) {
+			return null;
+		}
+
+		return '{'.$this->namespaceURI.'}'.$this->localName;
+	}
+
+	/**
+	 * Reads the entire document.
+	 *
+	 * This function returns an array with the following three elements:
+	 *    * name - The root element name.
+	 *    * value - The value for the root element.
+	 *    * attributes - An array of attributes.
+	 *
+	 * This function will also disable the standard libxml error handler (which
+	 * usually just results in PHP errors), and throw exceptions instead.
+	 */
+	public function parse(): array
+	{
+		$previousEntityState = null;
+		$shouldCallLibxmlDisableEntityLoader = (\LIBXML_VERSION < 20900);
+		if ($shouldCallLibxmlDisableEntityLoader) {
+			$previousEntityState = libxml_disable_entity_loader(true);
+		}
+		$previousSetting = libxml_use_internal_errors(true);
+
+		try {
+			while (self::ELEMENT !== $this->nodeType) {
+				if (!$this->read()) {
+					$errors = libxml_get_errors();
+					libxml_clear_errors();
+					if ($errors) {
+						throw new LibXMLException($errors);
+					}
+				}
+			}
+			$result = $this->parseCurrentElement();
+
+			// last line of defense in case errors did occur above
+			$errors = libxml_get_errors();
+			libxml_clear_errors();
+			if ($errors) {
+				throw new LibXMLException($errors);
+			}
+		} finally {
+			libxml_use_internal_errors($previousSetting);
+			if ($shouldCallLibxmlDisableEntityLoader) {
+				libxml_disable_entity_loader($previousEntityState);
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * parseGetElements parses everything in the current sub-tree,
+	 * and returns an array of elements.
+	 *
+	 * Each element has a 'name', 'value' and 'attributes' key.
+	 *
+	 * If the element didn't contain sub-elements, an empty array is always
+	 * returned. If there was any text inside the element, it will be
+	 * discarded.
+	 *
+	 * If the $elementMap argument is specified, the existing elementMap will
+	 * be overridden while parsing the tree, and restored after this process.
+	 */
+	public function parseGetElements(array $elementMap = null): array
+	{
+		$result = $this->parseInnerTree($elementMap);
+		if (!is_array($result)) {
+			return [];
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Parses all elements below the current element.
+	 *
+	 * This method will return a string if this was a text-node, or an array if
+	 * there were sub-elements.
+	 *
+	 * If there's both text and sub-elements, the text will be discarded.
+	 *
+	 * If the $elementMap argument is specified, the existing elementMap will
+	 * be overridden while parsing the tree, and restored after this process.
+	 *
+	 * @return array|string|null
+	 */
+	public function parseInnerTree(array $elementMap = null)
+	{
+		$text = null;
+		$elements = [];
+
+		if (self::ELEMENT === $this->nodeType && $this->isEmptyElement) {
+			// Easy!
+			$this->next();
+
+			return null;
+		}
+
+		if (!is_null($elementMap)) {
+			$this->pushContext();
+			$this->elementMap = $elementMap;
+		}
+
+		try {
+			if (!$this->read()) {
+				$errors = libxml_get_errors();
+				libxml_clear_errors();
+				if ($errors) {
+					throw new LibXMLException($errors);
+				}
+				throw new ParseException('This should never happen (famous last words)');
+			}
+
+			$keepOnParsing = true;
+
+			while ($keepOnParsing) {
+				if (!$this->isValid()) {
+					$errors = libxml_get_errors();
+
+					if ($errors) {
+						libxml_clear_errors();
+						throw new LibXMLException($errors);
+					}
+				}
+
+				switch ($this->nodeType) {
+					case self::ELEMENT:
+						$elements[] = $this->parseCurrentElement();
+						break;
+					case self::TEXT:
+					case self::CDATA:
+						$text .= $this->value;
+						$this->read();
+						break;
+					case self::END_ELEMENT:
+						// Ensuring we are moving the cursor after the end element.
+						$this->read();
+						$keepOnParsing = false;
+						break;
+					case self::NONE:
+						throw new ParseException('We hit the end of the document prematurely. This likely means that some parser "eats" too many elements. Do not attempt to continue parsing.');
+					default:
+						// Advance to the next element
+						$this->read();
+						break;
+				}
+			}
+		} finally {
+			if (!is_null($elementMap)) {
+				$this->popContext();
+			}
+		}
+
+		return $elements ? $elements : $text;
+	}
+
+	/**
+	 * Reads all text below the current element, and returns this as a string.
+	 */
+	public function readText(): string
+	{
+		$result = '';
+		$previousDepth = $this->depth;
+
+		while ($this->read() && $this->depth != $previousDepth) {
+			if (in_array($this->nodeType, [XMLReader::TEXT, XMLReader::CDATA, XMLReader::WHITESPACE])) {
+				$result .= $this->value;
+			}
+		}
+
+		return $result;
+	}
+
+	/**
+	 * Parses the current XML element.
+	 *
+	 * This method returns arn array with 3 properties:
+	 *   * name - A clark-notation XML element name.
+	 *   * value - The parsed value.
+	 *   * attributes - A key-value list of attributes.
+	 */
+	public function parseCurrentElement(): array
+	{
+		$name = $this->getClark();
+
+		$attributes = [];
+
+		if ($this->hasAttributes) {
+			$attributes = $this->parseAttributes();
+		}
+
+		$value = call_user_func(
+			$this->getDeserializerForElementName((string) $name),
+			$this
+		);
+
+		return [
+			'name' => $name,
+			'value' => $value,
+			'attributes' => $attributes,
+		];
+	}
+
+	/**
+	 * Grabs all the attributes from the current element, and returns them as a
+	 * key-value array.
+	 *
+	 * If the attributes are part of the same namespace, they will simply be
+	 * short keys. If they are defined on a different namespace, the attribute
+	 * name will be returned in clark-notation.
+	 */
+	public function parseAttributes(): array
+	{
+		$attributes = [];
+
+		while ($this->moveToNextAttribute()) {
+			if ($this->namespaceURI) {
+				// Ignoring 'xmlns', it doesn't make any sense.
+				if ('http://www.w3.org/2000/xmlns/' === $this->namespaceURI) {
+					continue;
+				}
+
+				$name = $this->getClark();
+				$attributes[$name] = $this->value;
+			} else {
+				$attributes[$this->localName] = $this->value;
+			}
+		}
+		$this->moveToElement();
+
+		return $attributes;
+	}
+
+	/**
+	 * Returns the function that should be used to parse the element identified
+	 * by its clark-notation name.
+	 */
+	public function getDeserializerForElementName(string $name): callable
+	{
+		if (!array_key_exists($name, $this->elementMap)) {
+			if ('{}' == substr($name, 0, 2) && array_key_exists(substr($name, 2), $this->elementMap)) {
+				$name = substr($name, 2);
+			} else {
+				return ['Sabre\\Xml\\Element\\Base', 'xmlDeserialize'];
+			}
+		}
+
+		$deserializer = $this->elementMap[$name];
+		if (is_subclass_of($deserializer, 'Sabre\\Xml\\XmlDeserializable')) {
+			return [$deserializer, 'xmlDeserialize'];
+		}
+
+		if (is_callable($deserializer)) {
+			return $deserializer;
+		}
+
+		$type = gettype($deserializer);
+		if ('string' === $type) {
+			$type .= ' ('.$deserializer.')';
+		} elseif ('object' === $type) {
+			$type .= ' ('.get_class($deserializer).')';
+		}
+		throw new \LogicException('Could not use this type as a deserializer: '.$type.' for element: '.$name);
+	}
 }

htdocs/includes/sabre/sabre/xml/lib/XmlSerializable.php

Indentation +17 added lines, -17 removed lines

@@ -14,21 +14,21 @@
  */
 interface XmlSerializable
 {
-    /**
-     * The xmlSerialize method is called during xml writing.
-     *
-     * Use the $writer argument to write its own xml serialization.
-     *
-     * An important note: do _not_ create a parent element. Any element
-     * implementing XmlSerializable should only ever write what's considered
-     * its 'inner xml'.
-     *
-     * The parent of the current element is responsible for writing a
-     * containing element.
-     *
-     * This allows serializers to be re-used for different element names.
-     *
-     * If you are opening new elements, you must also close them again.
-     */
-    public function xmlSerialize(Writer $writer);
+	/**
+	 * The xmlSerialize method is called during xml writing.
+	 *
+	 * Use the $writer argument to write its own xml serialization.
+	 *
+	 * An important note: do _not_ create a parent element. Any element
+	 * implementing XmlSerializable should only ever write what's considered
+	 * its 'inner xml'.
+	 *
+	 * The parent of the current element is responsible for writing a
+	 * containing element.
+	 *
+	 * This allows serializers to be re-used for different element names.
+	 *
+	 * If you are opening new elements, you must also close them again.
+	 */
+	public function xmlSerialize(Writer $writer);
 }

htdocs/includes/sabre/sabre/xml/lib/ContextStackTrait.php

Indentation +86 added lines, -86 removed lines

@@ -23,96 +23,96 @@
  */
 trait ContextStackTrait
 {
-    /**
-     * This is the element map. It contains a list of XML elements (in clark
-     * notation) as keys and PHP class names as values.
-     *
-     * The PHP class names must implement Sabre\Xml\Element.
-     *
-     * Values may also be a callable. In that case the function will be called
-     * directly.
-     *
-     * @var array
-     */
-    public $elementMap = [];
+	/**
+	 * This is the element map. It contains a list of XML elements (in clark
+	 * notation) as keys and PHP class names as values.
+	 *
+	 * The PHP class names must implement Sabre\Xml\Element.
+	 *
+	 * Values may also be a callable. In that case the function will be called
+	 * directly.
+	 *
+	 * @var array
+	 */
+	public $elementMap = [];
 
-    /**
-     * A contextUri pointing to the document being parsed / written.
-     * This uri may be used to resolve relative urls that may appear in the
-     * document.
-     *
-     * The reader and writer don't use this property, but as it's an extremely
-     * common use-case for parsing XML documents, it's added here as a
-     * convenience.
-     *
-     * @var string|null
-     */
-    public $contextUri;
+	/**
+	 * A contextUri pointing to the document being parsed / written.
+	 * This uri may be used to resolve relative urls that may appear in the
+	 * document.
+	 *
+	 * The reader and writer don't use this property, but as it's an extremely
+	 * common use-case for parsing XML documents, it's added here as a
+	 * convenience.
+	 *
+	 * @var string|null
+	 */
+	public $contextUri;
 
-    /**
-     * This is a list of namespaces that you want to give default prefixes.
-     *
-     * You must make sure you create this entire list before starting to write.
-     * They should be registered on the root element.
-     *
-     * @var array
-     */
-    public $namespaceMap = [];
+	/**
+	 * This is a list of namespaces that you want to give default prefixes.
+	 *
+	 * You must make sure you create this entire list before starting to write.
+	 * They should be registered on the root element.
+	 *
+	 * @var array
+	 */
+	public $namespaceMap = [];
 
-    /**
-     * This is a list of custom serializers for specific classes.
-     *
-     * The writer may use this if you attempt to serialize an object with a
-     * class that does not implement XmlSerializable.
-     *
-     * Instead it will look at this classmap to see if there is a custom
-     * serializer here. This is useful if you don't want your value objects
-     * to be responsible for serializing themselves.
-     *
-     * The keys in this classmap need to be fully qualified PHP class names,
-     * the values must be callbacks. The callbacks take two arguments. The
-     * writer class, and the value that must be written.
-     *
-     * function (Writer $writer, object $value)
-     *
-     * @var array
-     */
-    public $classMap = [];
+	/**
+	 * This is a list of custom serializers for specific classes.
+	 *
+	 * The writer may use this if you attempt to serialize an object with a
+	 * class that does not implement XmlSerializable.
+	 *
+	 * Instead it will look at this classmap to see if there is a custom
+	 * serializer here. This is useful if you don't want your value objects
+	 * to be responsible for serializing themselves.
+	 *
+	 * The keys in this classmap need to be fully qualified PHP class names,
+	 * the values must be callbacks. The callbacks take two arguments. The
+	 * writer class, and the value that must be written.
+	 *
+	 * function (Writer $writer, object $value)
+	 *
+	 * @var array
+	 */
+	public $classMap = [];
 
-    /**
-     * Backups of previous contexts.
-     *
-     * @var array
-     */
-    protected $contextStack = [];
+	/**
+	 * Backups of previous contexts.
+	 *
+	 * @var array
+	 */
+	protected $contextStack = [];
 
-    /**
-     * Create a new "context".
-     *
-     * This allows you to safely modify the elementMap, contextUri or
-     * namespaceMap. After you're done, you can restore the old data again
-     * with popContext.
-     */
-    public function pushContext()
-    {
-        $this->contextStack[] = [
-            $this->elementMap,
-            $this->contextUri,
-            $this->namespaceMap,
-            $this->classMap,
-        ];
-    }
+	/**
+	 * Create a new "context".
+	 *
+	 * This allows you to safely modify the elementMap, contextUri or
+	 * namespaceMap. After you're done, you can restore the old data again
+	 * with popContext.
+	 */
+	public function pushContext()
+	{
+		$this->contextStack[] = [
+			$this->elementMap,
+			$this->contextUri,
+			$this->namespaceMap,
+			$this->classMap,
+		];
+	}
 
-    /**
-     * Restore the previous "context".
-     */
-    public function popContext()
-    {
-        list(
-            $this->elementMap,
-            $this->contextUri,
-            $this->namespaceMap,
-            $this->classMap
-        ) = array_pop($this->contextStack);
-    }
+	/**
+	 * Restore the previous "context".
+	 */
+	public function popContext()
+	{
+		list(
+			$this->elementMap,
+			$this->contextUri,
+			$this->namespaceMap,
+			$this->classMap
+		) = array_pop($this->contextStack);
+	}
 }

htdocs/includes/restler/framework/Luracast/Restler/Data/Text.php

Braces +6 added lines, -3 removed lines

@@ -25,8 +25,9 @@ 
 	 */
 	public static function contains($haystack, $needle, $caseSensitive = true)
 	{
-		if (empty($needle))
-			return true;
+		if (empty($needle)) {
+					return true;
+		}
 			return $caseSensitive
 			? strpos($haystack, $needle) !== false
 			: stripos($haystack, $needle) !== false;
@@ -62,7 +63,9 @@ 
 		}
 		
 		// @CHANGE LDR
-		if (!is_string($haystack)) return false;
+		if (!is_string($haystack)) {
+			return false;
+		}
 		
 		return (substr($haystack, -$length) === $needle);
 	}

htdocs/includes/restler/framework/Luracast/Restler/Data/Arr.php

Indentation +17 added lines, -17 removed lines

@@ -14,21 +14,21 @@
  */
 class Arr
 {
-    /**
-     * Deep copy given array
-     *
-     * @param array $arr
-     *
-     * @return array
-     */
-    public static function copy(array $arr)
-    {
-        $copy = array();
-        foreach ($arr as $key => $value) {
-            if (is_array($value)) $copy[$key] = static::copy($value);
-            else if (is_object($value)) $copy[$key] = clone $value;
-            else $copy[$key] = $value;
-        }
-        return $copy;
-    }
+	/**
+	 * Deep copy given array
+	 *
+	 * @param array $arr
+	 *
+	 * @return array
+	 */
+	public static function copy(array $arr)
+	{
+		$copy = array();
+		foreach ($arr as $key => $value) {
+			if (is_array($value)) $copy[$key] = static::copy($value);
+			else if (is_object($value)) $copy[$key] = clone $value;
+			else $copy[$key] = $value;
+		}
+		return $copy;
+	}
 } 
\ No newline at end of file

Braces +7 added lines, -3 removed lines

@@ -25,9 +25,13 @@
     {
         $copy = array();
         foreach ($arr as $key => $value) {
-            if (is_array($value)) $copy[$key] = static::copy($value);
-            else if (is_object($value)) $copy[$key] = clone $value;
-            else $copy[$key] = $value;
+            if (is_array($value)) {
+            	$copy[$key] = static::copy($value);
+            } else if (is_object($value)) {
+            	$copy[$key] = clone $value;
+            } else {
+            	$copy[$key] = $value;
+            }
         }
         return $copy;
     }

htdocs/includes/restler/framework/Luracast/Restler/Data/iValidate.php

Indentation +14 added lines, -14 removed lines

@@ -14,19 +14,19 @@
  */
 interface iValidate {
 
-    /**
-     * method used for validation.
-     *
-     * @param mixed $input
-     *            data that needs to be validated
-     * @param ValidationInfo $info
-     *            information to be used for validation
-     * @return boolean false in case of failure or fixed value in the expected
-     *         type
-     * @throws \Luracast\Restler\RestException 400 with information about the
-     * failed
-     * validation
-     */
-    public static function validate($input, ValidationInfo $info);
+	/**
+	 * method used for validation.
+	 *
+	 * @param mixed $input
+	 *            data that needs to be validated
+	 * @param ValidationInfo $info
+	 *            information to be used for validation
+	 * @return boolean false in case of failure or fixed value in the expected
+	 *         type
+	 * @throws \Luracast\Restler\RestException 400 with information about the
+	 * failed
+	 * validation
+	 */
+	public static function validate($input, ValidationInfo $info);
 }