Dolibarr / dolibarr

htdocs/includes/sabre/sabre/xml/lib/Serializer/functions.php

Indentation +68 added lines, -68 removed lines

@@ -40,9 +40,9 @@ 
  */
 function enum(Writer $writer, array $values)
 {
-    foreach ($values as $value) {
-        $writer->writeElement($value);
-    }
+	foreach ($values as $value) {
+		$writer->writeElement($value);
+	}
 }
 
 /**
@@ -58,17 +58,17 @@ 
  */
 function valueObject(Writer $writer, $valueObject, string $namespace)
 {
-    foreach (get_object_vars($valueObject) as $key => $val) {
-        if (is_array($val)) {
-            // If $val is an array, it has a special meaning. We need to
-            // generate one child element for each item in $val
-            foreach ($val as $child) {
-                $writer->writeElement('{'.$namespace.'}'.$key, $child);
-            }
-        } elseif (null !== $val) {
-            $writer->writeElement('{'.$namespace.'}'.$key, $val);
-        }
-    }
+	foreach (get_object_vars($valueObject) as $key => $val) {
+		if (is_array($val)) {
+			// If $val is an array, it has a special meaning. We need to
+			// generate one child element for each item in $val
+			foreach ($val as $child) {
+				$writer->writeElement('{'.$namespace.'}'.$key, $child);
+			}
+		} elseif (null !== $val) {
+			$writer->writeElement('{'.$namespace.'}'.$key, $val);
+		}
+	}
 }
 
 /**
@@ -88,9 +88,9 @@ 
  */
 function repeatingElements(Writer $writer, array $items, string $childElementName)
 {
-    foreach ($items as $item) {
-        $writer->writeElement($childElementName, $item);
-    }
+	foreach ($items as $item) {
+		$writer->writeElement($childElementName, $item);
+	}
 }
 
 /**
@@ -152,57 +152,57 @@ 
  */
 function standardSerializer(Writer $writer, $value)
 {
-    if (is_scalar($value)) {
-        // String, integer, float, boolean
-        $writer->text((string) $value);
-    } elseif ($value instanceof XmlSerializable) {
-        // XmlSerializable classes or Element classes.
-        $value->xmlSerialize($writer);
-    } elseif (is_object($value) && isset($writer->classMap[get_class($value)])) {
-        // It's an object which class appears in the classmap.
-        $writer->classMap[get_class($value)]($writer, $value);
-    } elseif (is_callable($value)) {
-        // A callback
-        $value($writer);
-    } elseif (is_array($value) && array_key_exists('name', $value)) {
-        // if the array had a 'name' element, we assume that this array
-        // describes a 'name' and optionally 'attributes' and 'value'.
+	if (is_scalar($value)) {
+		// String, integer, float, boolean
+		$writer->text((string) $value);
+	} elseif ($value instanceof XmlSerializable) {
+		// XmlSerializable classes or Element classes.
+		$value->xmlSerialize($writer);
+	} elseif (is_object($value) && isset($writer->classMap[get_class($value)])) {
+		// It's an object which class appears in the classmap.
+		$writer->classMap[get_class($value)]($writer, $value);
+	} elseif (is_callable($value)) {
+		// A callback
+		$value($writer);
+	} elseif (is_array($value) && array_key_exists('name', $value)) {
+		// if the array had a 'name' element, we assume that this array
+		// describes a 'name' and optionally 'attributes' and 'value'.
 
-        $name = $value['name'];
-        $attributes = isset($value['attributes']) ? $value['attributes'] : [];
-        $value = isset($value['value']) ? $value['value'] : null;
+		$name = $value['name'];
+		$attributes = isset($value['attributes']) ? $value['attributes'] : [];
+		$value = isset($value['value']) ? $value['value'] : null;
 
-        $writer->startElement($name);
-        $writer->writeAttributes($attributes);
-        $writer->write($value);
-        $writer->endElement();
-    } elseif (is_array($value)) {
-        foreach ($value as $name => $item) {
-            if (is_int($name)) {
-                // This item has a numeric index. We just loop through the
-                // array and throw it back in the writer.
-                standardSerializer($writer, $item);
-            } elseif (is_string($name) && is_array($item) && isset($item['attributes'])) {
-                // The key is used for a name, but $item has 'attributes' and
-                // possibly 'value'
-                $writer->startElement($name);
-                $writer->writeAttributes($item['attributes']);
-                if (isset($item['value'])) {
-                    $writer->write($item['value']);
-                }
-                $writer->endElement();
-            } elseif (is_string($name)) {
-                // This was a plain key-value array.
-                $writer->startElement($name);
-                $writer->write($item);
-                $writer->endElement();
-            } else {
-                throw new InvalidArgumentException('The writer does not know how to serialize arrays with keys of type: '.gettype($name));
-            }
-        }
-    } elseif (is_object($value)) {
-        throw new InvalidArgumentException('The writer cannot serialize objects of class: '.get_class($value));
-    } elseif (!is_null($value)) {
-        throw new InvalidArgumentException('The writer cannot serialize values of type: '.gettype($value));
-    }
+		$writer->startElement($name);
+		$writer->writeAttributes($attributes);
+		$writer->write($value);
+		$writer->endElement();
+	} elseif (is_array($value)) {
+		foreach ($value as $name => $item) {
+			if (is_int($name)) {
+				// This item has a numeric index. We just loop through the
+				// array and throw it back in the writer.
+				standardSerializer($writer, $item);
+			} elseif (is_string($name) && is_array($item) && isset($item['attributes'])) {
+				// The key is used for a name, but $item has 'attributes' and
+				// possibly 'value'
+				$writer->startElement($name);
+				$writer->writeAttributes($item['attributes']);
+				if (isset($item['value'])) {
+					$writer->write($item['value']);
+				}
+				$writer->endElement();
+			} elseif (is_string($name)) {
+				// This was a plain key-value array.
+				$writer->startElement($name);
+				$writer->write($item);
+				$writer->endElement();
+			} else {
+				throw new InvalidArgumentException('The writer does not know how to serialize arrays with keys of type: '.gettype($name));
+			}
+		}
+	} elseif (is_object($value)) {
+		throw new InvalidArgumentException('The writer cannot serialize objects of class: '.get_class($value));
+	} elseif (!is_null($value)) {
+		throw new InvalidArgumentException('The writer cannot serialize values of type: '.gettype($value));
+	}
 }

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

Indentation +21 added lines, -21 removed lines

@@ -14,25 +14,25 @@
  */
 interface XmlDeserializable
 {
-    /**
-     * 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);
+	/**
+	 * 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);
 }

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 = [];
 }

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

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