Dolibarr / dolibarr

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

Indentation +292 added lines, -292 removed lines

@@ -17,296 +17,296 @@
  */
 class Service
 {
-    /**
-     * 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 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 = [];
-
-    /**
-     * A bitmask of the LIBXML_* constants.
-     *
-     * @var int
-     */
-    public $options = 0;
-
-    /**
-     * Returns a fresh XML Reader.
-     */
-    public function getReader(): Reader
-    {
-        $r = new Reader();
-        $r->elementMap = $this->elementMap;
-
-        return $r;
-    }
-
-    /**
-     * Returns a fresh xml writer.
-     */
-    public function getWriter(): Writer
-    {
-        $w = new Writer();
-        $w->namespaceMap = $this->namespaceMap;
-        $w->classMap = $this->classMap;
-
-        return $w;
-    }
-
-    /**
-     * Parses a document in full.
-     *
-     * Input may be specified as a string or readable stream resource.
-     * The returned value is the value of the root document.
-     *
-     * Specifying the $contextUri allows the parser to figure out what the URI
-     * of the document was. This allows relative URIs within the document to be
-     * expanded easily.
-     *
-     * The $rootElementName is specified by reference and will be populated
-     * with the root element name of the document.
-     *
-     * @param string|resource $input
-     *
-     * @throws ParseException
-     *
-     * @return array|object|string
-     */
-    public function parse($input, string $contextUri = null, string &$rootElementName = null)
-    {
-        if (is_resource($input)) {
-            // Unfortunately the XMLReader doesn't support streams. When it
-            // does, we can optimize this.
-            $input = (string) stream_get_contents($input);
-        }
-
-        // If input is empty, then it's safe to throw an exception
-        if (empty($input)) {
-            throw new ParseException('The input element to parse is empty. Do not attempt to parse');
-        }
-
-        $r = $this->getReader();
-        $r->contextUri = $contextUri;
-        $r->XML($input, null, $this->options);
-
-        $result = $r->parse();
-        $rootElementName = $result['name'];
-
-        return $result['value'];
-    }
-
-    /**
-     * Parses a document in full, and specify what the expected root element
-     * name is.
-     *
-     * This function works similar to parse, but the difference is that the
-     * user can specify what the expected name of the root element should be,
-     * in clark notation.
-     *
-     * This is useful in cases where you expected a specific document to be
-     * passed, and reduces the amount of if statements.
-     *
-     * It's also possible to pass an array of expected rootElements if your
-     * code may expect more than one document type.
-     *
-     * @param string|string[] $rootElementName
-     * @param string|resource $input
-     *
-     * @throws ParseException
-     *
-     * @return array|object|string
-     */
-    public function expect($rootElementName, $input, string $contextUri = null)
-    {
-        if (is_resource($input)) {
-            // Unfortunately the XMLReader doesn't support streams. When it
-            // does, we can optimize this.
-            $input = (string) stream_get_contents($input);
-        }
-
-        // If input is empty, then it's safe to throw an exception
-        if (empty($input)) {
-            throw new ParseException('The input element to parse is empty. Do not attempt to parse');
-        }
-
-        $r = $this->getReader();
-        $r->contextUri = $contextUri;
-        $r->XML($input, null, $this->options);
-
-        $rootElementName = (array) $rootElementName;
-
-        foreach ($rootElementName as &$rEl) {
-            if ('{' !== $rEl[0]) {
-                $rEl = '{}'.$rEl;
-            }
-        }
-
-        $result = $r->parse();
-        if (!in_array($result['name'], $rootElementName, true)) {
-            throw new ParseException('Expected '.implode(' or ', $rootElementName).' but received '.$result['name'].' as the root element');
-        }
-
-        return $result['value'];
-    }
-
-    /**
-     * Generates an XML document in one go.
-     *
-     * The $rootElement must be specified in clark notation.
-     * The value must be a string, an array or an object implementing
-     * XmlSerializable. Basically, anything that's supported by the Writer
-     * object.
-     *
-     * $contextUri can be used to specify a sort of 'root' of the PHP application,
-     * in case the xml document is used as a http response.
-     *
-     * This allows an implementor to easily create URI's relative to the root
-     * of the domain.
-     *
-     * @param string|array|object|XmlSerializable $value
-     *
-     * @return string
-     */
-    public function write(string $rootElementName, $value, string $contextUri = null)
-    {
-        $w = $this->getWriter();
-        $w->openMemory();
-        $w->contextUri = $contextUri;
-        $w->setIndent(true);
-        $w->startDocument();
-        $w->writeElement($rootElementName, $value);
-
-        return $w->outputMemory();
-    }
-
-    /**
-     * Map an XML element to a PHP class.
-     *
-     * Calling this function will automatically set up the Reader and Writer
-     * classes to turn a specific XML element to a PHP class.
-     *
-     * For example, given a class such as :
-     *
-     * class Author {
-     *   public $firstName;
-     *   public $lastName;
-     * }
-     *
-     * and an XML element such as:
-     *
-     * <author xmlns="http://example.org/ns">
-     *   <firstName>...</firstName>
-     *   <lastName>...</lastName>
-     * </author>
-     *
-     * These can easily be mapped by calling:
-     *
-     * $service->mapValueObject('{http://example.org}author', 'Author');
-     */
-    public function mapValueObject(string $elementName, string $className)
-    {
-        list($namespace) = self::parseClarkNotation($elementName);
-
-        $this->elementMap[$elementName] = function (Reader $reader) use ($className, $namespace) {
-            return \Sabre\Xml\Deserializer\valueObject($reader, $className, $namespace);
-        };
-        $this->classMap[$className] = function (Writer $writer, $valueObject) use ($namespace) {
-            return \Sabre\Xml\Serializer\valueObject($writer, $valueObject, $namespace);
-        };
-        $this->valueObjectMap[$className] = $elementName;
-    }
-
-    /**
-     * Writes a value object.
-     *
-     * This function largely behaves similar to write(), except that it's
-     * intended specifically to serialize a Value Object into an XML document.
-     *
-     * The ValueObject must have been previously registered using
-     * mapValueObject().
-     *
-     * @param object $object
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function writeValueObject($object, string $contextUri = null)
-    {
-        if (!isset($this->valueObjectMap[get_class($object)])) {
-            throw new \InvalidArgumentException('"'.get_class($object).'" is not a registered value object class. Register your class with mapValueObject.');
-        }
-
-        return $this->write(
-            $this->valueObjectMap[get_class($object)],
-            $object,
-            $contextUri
-        );
-    }
-
-    /**
-     * Parses a clark-notation string, and returns the namespace and element
-     * name components.
-     *
-     * If the string was invalid, it will throw an InvalidArgumentException.
-     *
-     * @throws \InvalidArgumentException
-     */
-    public static function parseClarkNotation(string $str): array
-    {
-        static $cache = [];
-
-        if (!isset($cache[$str])) {
-            if (!preg_match('/^{([^}]*)}(.*)$/', $str, $matches)) {
-                throw new \InvalidArgumentException('\''.$str.'\' is not a valid clark-notation formatted string');
-            }
-
-            $cache[$str] = [
-                $matches[1],
-                $matches[2],
-            ];
-        }
-
-        return $cache[$str];
-    }
-
-    /**
-     * A list of classes and which XML elements they map to.
-     */
-    protected $valueObjectMap = [];
+	/**
+	 * 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 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 = [];
+
+	/**
+	 * A bitmask of the LIBXML_* constants.
+	 *
+	 * @var int
+	 */
+	public $options = 0;
+
+	/**
+	 * Returns a fresh XML Reader.
+	 */
+	public function getReader(): Reader
+	{
+		$r = new Reader();
+		$r->elementMap = $this->elementMap;
+
+		return $r;
+	}
+
+	/**
+	 * Returns a fresh xml writer.
+	 */
+	public function getWriter(): Writer
+	{
+		$w = new Writer();
+		$w->namespaceMap = $this->namespaceMap;
+		$w->classMap = $this->classMap;
+
+		return $w;
+	}
+
+	/**
+	 * Parses a document in full.
+	 *
+	 * Input may be specified as a string or readable stream resource.
+	 * The returned value is the value of the root document.
+	 *
+	 * Specifying the $contextUri allows the parser to figure out what the URI
+	 * of the document was. This allows relative URIs within the document to be
+	 * expanded easily.
+	 *
+	 * The $rootElementName is specified by reference and will be populated
+	 * with the root element name of the document.
+	 *
+	 * @param string|resource $input
+	 *
+	 * @throws ParseException
+	 *
+	 * @return array|object|string
+	 */
+	public function parse($input, string $contextUri = null, string &$rootElementName = null)
+	{
+		if (is_resource($input)) {
+			// Unfortunately the XMLReader doesn't support streams. When it
+			// does, we can optimize this.
+			$input = (string) stream_get_contents($input);
+		}
+
+		// If input is empty, then it's safe to throw an exception
+		if (empty($input)) {
+			throw new ParseException('The input element to parse is empty. Do not attempt to parse');
+		}
+
+		$r = $this->getReader();
+		$r->contextUri = $contextUri;
+		$r->XML($input, null, $this->options);
+
+		$result = $r->parse();
+		$rootElementName = $result['name'];
+
+		return $result['value'];
+	}
+
+	/**
+	 * Parses a document in full, and specify what the expected root element
+	 * name is.
+	 *
+	 * This function works similar to parse, but the difference is that the
+	 * user can specify what the expected name of the root element should be,
+	 * in clark notation.
+	 *
+	 * This is useful in cases where you expected a specific document to be
+	 * passed, and reduces the amount of if statements.
+	 *
+	 * It's also possible to pass an array of expected rootElements if your
+	 * code may expect more than one document type.
+	 *
+	 * @param string|string[] $rootElementName
+	 * @param string|resource $input
+	 *
+	 * @throws ParseException
+	 *
+	 * @return array|object|string
+	 */
+	public function expect($rootElementName, $input, string $contextUri = null)
+	{
+		if (is_resource($input)) {
+			// Unfortunately the XMLReader doesn't support streams. When it
+			// does, we can optimize this.
+			$input = (string) stream_get_contents($input);
+		}
+
+		// If input is empty, then it's safe to throw an exception
+		if (empty($input)) {
+			throw new ParseException('The input element to parse is empty. Do not attempt to parse');
+		}
+
+		$r = $this->getReader();
+		$r->contextUri = $contextUri;
+		$r->XML($input, null, $this->options);
+
+		$rootElementName = (array) $rootElementName;
+
+		foreach ($rootElementName as &$rEl) {
+			if ('{' !== $rEl[0]) {
+				$rEl = '{}'.$rEl;
+			}
+		}
+
+		$result = $r->parse();
+		if (!in_array($result['name'], $rootElementName, true)) {
+			throw new ParseException('Expected '.implode(' or ', $rootElementName).' but received '.$result['name'].' as the root element');
+		}
+
+		return $result['value'];
+	}
+
+	/**
+	 * Generates an XML document in one go.
+	 *
+	 * The $rootElement must be specified in clark notation.
+	 * The value must be a string, an array or an object implementing
+	 * XmlSerializable. Basically, anything that's supported by the Writer
+	 * object.
+	 *
+	 * $contextUri can be used to specify a sort of 'root' of the PHP application,
+	 * in case the xml document is used as a http response.
+	 *
+	 * This allows an implementor to easily create URI's relative to the root
+	 * of the domain.
+	 *
+	 * @param string|array|object|XmlSerializable $value
+	 *
+	 * @return string
+	 */
+	public function write(string $rootElementName, $value, string $contextUri = null)
+	{
+		$w = $this->getWriter();
+		$w->openMemory();
+		$w->contextUri = $contextUri;
+		$w->setIndent(true);
+		$w->startDocument();
+		$w->writeElement($rootElementName, $value);
+
+		return $w->outputMemory();
+	}
+
+	/**
+	 * Map an XML element to a PHP class.
+	 *
+	 * Calling this function will automatically set up the Reader and Writer
+	 * classes to turn a specific XML element to a PHP class.
+	 *
+	 * For example, given a class such as :
+	 *
+	 * class Author {
+	 *   public $firstName;
+	 *   public $lastName;
+	 * }
+	 *
+	 * and an XML element such as:
+	 *
+	 * <author xmlns="http://example.org/ns">
+	 *   <firstName>...</firstName>
+	 *   <lastName>...</lastName>
+	 * </author>
+	 *
+	 * These can easily be mapped by calling:
+	 *
+	 * $service->mapValueObject('{http://example.org}author', 'Author');
+	 */
+	public function mapValueObject(string $elementName, string $className)
+	{
+		list($namespace) = self::parseClarkNotation($elementName);
+
+		$this->elementMap[$elementName] = function (Reader $reader) use ($className, $namespace) {
+			return \Sabre\Xml\Deserializer\valueObject($reader, $className, $namespace);
+		};
+		$this->classMap[$className] = function (Writer $writer, $valueObject) use ($namespace) {
+			return \Sabre\Xml\Serializer\valueObject($writer, $valueObject, $namespace);
+		};
+		$this->valueObjectMap[$className] = $elementName;
+	}
+
+	/**
+	 * Writes a value object.
+	 *
+	 * This function largely behaves similar to write(), except that it's
+	 * intended specifically to serialize a Value Object into an XML document.
+	 *
+	 * The ValueObject must have been previously registered using
+	 * mapValueObject().
+	 *
+	 * @param object $object
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function writeValueObject($object, string $contextUri = null)
+	{
+		if (!isset($this->valueObjectMap[get_class($object)])) {
+			throw new \InvalidArgumentException('"'.get_class($object).'" is not a registered value object class. Register your class with mapValueObject.');
+		}
+
+		return $this->write(
+			$this->valueObjectMap[get_class($object)],
+			$object,
+			$contextUri
+		);
+	}
+
+	/**
+	 * Parses a clark-notation string, and returns the namespace and element
+	 * name components.
+	 *
+	 * If the string was invalid, it will throw an InvalidArgumentException.
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public static function parseClarkNotation(string $str): array
+	{
+		static $cache = [];
+
+		if (!isset($cache[$str])) {
+			if (!preg_match('/^{([^}]*)}(.*)$/', $str, $matches)) {
+				throw new \InvalidArgumentException('\''.$str.'\' is not a valid clark-notation formatted string');
+			}
+
+			$cache[$str] = [
+				$matches[1],
+				$matches[2],
+			];
+		}
+
+		return $cache[$str];
+	}
+
+	/**
+	 * A list of classes and which XML elements they map to.
+	 */
+	protected $valueObjectMap = [];
 }

Spacing +2 added lines, -2 removed lines

@@ -244,10 +244,10 @@
     {
         list($namespace) = self::parseClarkNotation($elementName);
 
-        $this->elementMap[$elementName] = function (Reader $reader) use ($className, $namespace) {
+        $this->elementMap[$elementName] = function(Reader $reader) use ($className, $namespace) {
             return \Sabre\Xml\Deserializer\valueObject($reader, $className, $namespace);
         };
-        $this->classMap[$className] = function (Writer $writer, $valueObject) use ($namespace) {
+        $this->classMap[$className] = function(Writer $writer, $valueObject) use ($namespace) {
             return \Sabre\Xml\Serializer\valueObject($writer, $valueObject, $namespace);
         };
         $this->valueObjectMap[$className] = $elementName;

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

Indentation +57 added lines, -57 removed lines

@@ -37,64 +37,64 @@
  */
 class Elements implements Xml\Element
 {
-    /**
-     * Value to serialize.
-     *
-     * @var array
-     */
-    protected $value;
+	/**
+	 * Value to serialize.
+	 *
+	 * @var array
+	 */
+	protected $value;
 
-    /**
-     * Constructor.
-     */
-    public function __construct(array $value = [])
-    {
-        $this->value = $value;
-    }
+	/**
+	 * Constructor.
+	 */
+	public function __construct(array $value = [])
+	{
+		$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)
-    {
-        Serializer\enum($writer, $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)
+	{
+		Serializer\enum($writer, $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->parseSubTree() will parse the entire sub-tree, and advance to
-     * the next element.
-     *
-     * @return mixed
-     */
-    public static function xmlDeserialize(Xml\Reader $reader)
-    {
-        return Deserializer\enum($reader);
-    }
+	/**
+	 * 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->parseSubTree() will parse the entire sub-tree, and advance to
+	 * the next element.
+	 *
+	 * @return mixed
+	 */
+	public static function xmlDeserialize(Xml\Reader $reader)
+	{
+		return Deserializer\enum($reader);
+	}
 }

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

Indentation +69 added lines, -69 removed lines

@@ -24,76 +24,76 @@
  */
 class Uri implements Xml\Element
 {
-    /**
-     * Uri element value.
-     *
-     * @var string
-     */
-    protected $value;
+	/**
+	 * Uri element value.
+	 *
+	 * @var string
+	 */
+	protected $value;
 
-    /**
-     * Constructor.
-     *
-     * @param string $value
-     */
-    public function __construct($value)
-    {
-        $this->value = $value;
-    }
+	/**
+	 * Constructor.
+	 *
+	 * @param string $value
+	 */
+	public function __construct($value)
+	{
+		$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->text(
-            \Sabre\Uri\resolve(
-                $writer->contextUri,
-                $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->text(
+			\Sabre\Uri\resolve(
+				$writer->contextUri,
+				$this->value
+			)
+		);
+	}
 
-    /**
-     * This 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->parseSubTree() will parse the entire sub-tree, and advance to
-     * the next element.
-     *
-     * @return mixed
-     */
-    public static function xmlDeserialize(Xml\Reader $reader)
-    {
-        return new self(
-            \Sabre\Uri\resolve(
-                (string) $reader->contextUri,
-                $reader->readText()
-            )
-        );
-    }
+	/**
+	 * This 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->parseSubTree() will parse the entire sub-tree, and advance to
+	 * the next element.
+	 *
+	 * @return mixed
+	 */
+	public static function xmlDeserialize(Xml\Reader $reader)
+	{
+		return new self(
+			\Sabre\Uri\resolve(
+				(string) $reader->contextUri,
+				$reader->readText()
+			)
+		);
+	}
 }

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

Indentation +109 added lines, -109 removed lines

@@ -24,125 +24,125 @@
  */
 class XmlFragment implements Element
 {
-    /**
-     * The inner XML value.
-     *
-     * @var string
-     */
-    protected $xml;
+	/**
+	 * The inner XML value.
+	 *
+	 * @var string
+	 */
+	protected $xml;
 
-    /**
-     * Constructor.
-     */
-    public function __construct(string $xml)
-    {
-        $this->xml = $xml;
-    }
+	/**
+	 * Constructor.
+	 */
+	public function __construct(string $xml)
+	{
+		$this->xml = $xml;
+	}
 
-    /**
-     * Returns the inner XML document.
-     */
-    public function getXml(): string
-    {
-        return $this->xml;
-    }
+	/**
+	 * Returns the inner XML document.
+	 */
+	public function getXml(): string
+	{
+		return $this->xml;
+	}
 
-    /**
-     * 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)
-    {
-        $reader = new Reader();
+	/**
+	 * 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)
+	{
+		$reader = new Reader();
 
-        // Wrapping the xml in a container, so root-less values can still be
-        // parsed.
-        $xml = <<<XML
+		// Wrapping the xml in a container, so root-less values can still be
+		// parsed.
+		$xml = <<<XML
 <?xml version="1.0"?>
 <xml-fragment xmlns="http://sabre.io/ns">{$this->getXml()}</xml-fragment>
 XML;
 
-        $reader->xml($xml);
+		$reader->xml($xml);
 
-        while ($reader->read()) {
-            if ($reader->depth < 1) {
-                // Skipping the root node.
-                continue;
-            }
+		while ($reader->read()) {
+			if ($reader->depth < 1) {
+				// Skipping the root node.
+				continue;
+			}
 
-            switch ($reader->nodeType) {
-                case Reader::ELEMENT:
-                    $writer->startElement(
-                        (string) $reader->getClark()
-                    );
-                    $empty = $reader->isEmptyElement;
-                    while ($reader->moveToNextAttribute()) {
-                        switch ($reader->namespaceURI) {
-                            case '':
-                                $writer->writeAttribute($reader->localName, $reader->value);
-                                break;
-                            case 'http://www.w3.org/2000/xmlns/':
-                                // Skip namespace declarations
-                                break;
-                            default:
-                                $writer->writeAttribute((string) $reader->getClark(), $reader->value);
-                                break;
-                        }
-                    }
-                    if ($empty) {
-                        $writer->endElement();
-                    }
-                    break;
-                case Reader::CDATA:
-                case Reader::TEXT:
-                    $writer->text(
-                        $reader->value
-                    );
-                    break;
-                case Reader::END_ELEMENT:
-                    $writer->endElement();
-                    break;
-            }
-        }
-    }
+			switch ($reader->nodeType) {
+				case Reader::ELEMENT:
+					$writer->startElement(
+						(string) $reader->getClark()
+					);
+					$empty = $reader->isEmptyElement;
+					while ($reader->moveToNextAttribute()) {
+						switch ($reader->namespaceURI) {
+							case '':
+								$writer->writeAttribute($reader->localName, $reader->value);
+								break;
+							case 'http://www.w3.org/2000/xmlns/':
+								// Skip namespace declarations
+								break;
+							default:
+								$writer->writeAttribute((string) $reader->getClark(), $reader->value);
+								break;
+						}
+					}
+					if ($empty) {
+						$writer->endElement();
+					}
+					break;
+				case Reader::CDATA:
+				case Reader::TEXT:
+					$writer->text(
+						$reader->value
+					);
+					break;
+				case Reader::END_ELEMENT:
+					$writer->endElement();
+					break;
+			}
+		}
+	}
 
-    /**
-     * 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.
-     *
-     * 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(Reader $reader)
-    {
-        $result = new self($reader->readInnerXml());
-        $reader->next();
+	/**
+	 * 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.
+	 *
+	 * 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(Reader $reader)
+	{
+		$result = new self($reader->readInnerXml());
+		$reader->next();
 
-        return $result;
-    }
+		return $result;
+	}
 }

Upper-Lower-Casing +1 added lines, -1 removed lines

@@ -72,7 +72,7 @@
         $xml = <<<XML
 <?xml version="1.0"?>
 <xml-fragment xmlns="http://sabre.io/ns">{$this->getXml()}</xml-fragment>
-XML;
+xml;
 
         $reader->xml($xml);
 

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

Indentation +57 added lines, -57 removed lines

@@ -37,64 +37,64 @@
  */
 class KeyValue implements Xml\Element
 {
-    /**
-     * Value to serialize.
-     *
-     * @var array
-     */
-    protected $value;
+	/**
+	 * Value to serialize.
+	 *
+	 * @var array
+	 */
+	protected $value;
 
-    /**
-     * Constructor.
-     */
-    public function __construct(array $value = [])
-    {
-        $this->value = $value;
-    }
+	/**
+	 * Constructor.
+	 */
+	public function __construct(array $value = [])
+	{
+		$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)
-    {
-        return Deserializer\keyValue($reader);
-    }
+	/**
+	 * 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)
+	{
+		return Deserializer\keyValue($reader);
+	}
 }

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

Indentation +33 added lines, -33 removed lines

@@ -21,39 +21,39 @@
  */
 class Cdata implements Xml\XmlSerializable
 {
-    /**
-     * CDATA element value.
-     *
-     * @var string
-     */
-    protected $value;
+	/**
+	 * CDATA element value.
+	 *
+	 * @var string
+	 */
+	protected $value;
 
-    /**
-     * Constructor.
-     */
-    public function __construct(string $value)
-    {
-        $this->value = $value;
-    }
+	/**
+	 * Constructor.
+	 */
+	public function __construct(string $value)
+	{
+		$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->writeCData($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->writeCData($this->value);
+	}
 }

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
+		);
+	}
 }