Dolibarr / dolibarr

htdocs/includes/restler/framework/Luracast/Restler/UI/Nav.php

Indentation +185 added lines, -185 removed lines

@@ -23,201 +23,201 @@
  */
 class Nav
 {
-    protected static $tree = array();
-    public static $root = 'home';
+	protected static $tree = array();
+	public static $root = 'home';
 
-    /**
-     * @var array all paths beginning with any of the following will be excluded
-     * from documentation. if an empty string is given it will exclude the root
-     */
-    public static $excludedPaths = array('');
-    /**
-     * @var array prefix additional menu items with one of the following syntax
-     *            [$path => $text]
-     *            [$path]
-     *            [$path => ['text' => $text, 'url' => $url, 'trail'=> $trail]]
-     */
-    public static $prepends = array();
-    /**
-     * @var array suffix additional menu items with one of the following syntax
-     *            [$path => $text]
-     *            [$path]
-     *            [$path => ['text' => $text, 'url' => $url, 'trail'=> $trail]]
-     */
-    public static $appends = array();
+	/**
+	 * @var array all paths beginning with any of the following will be excluded
+	 * from documentation. if an empty string is given it will exclude the root
+	 */
+	public static $excludedPaths = array('');
+	/**
+	 * @var array prefix additional menu items with one of the following syntax
+	 *            [$path => $text]
+	 *            [$path]
+	 *            [$path => ['text' => $text, 'url' => $url, 'trail'=> $trail]]
+	 */
+	public static $prepends = array();
+	/**
+	 * @var array suffix additional menu items with one of the following syntax
+	 *            [$path => $text]
+	 *            [$path]
+	 *            [$path => ['text' => $text, 'url' => $url, 'trail'=> $trail]]
+	 */
+	public static $appends = array();
 
-    public static $addExtension = true;
+	public static $addExtension = true;
 
-    protected static $extension = '';
-    protected static $activeTrail = '';
-    protected static $url;
+	protected static $extension = '';
+	protected static $activeTrail = '';
+	protected static $url;
 
-    public static function get($for = '', $activeTrail = null)
-    {
-        if (empty(static::$tree)) {
-            /** @var Restler $restler */
-            $restler = Scope::get('Restler');
-            if (static::$addExtension)
-                static::$extension = isset($restler->responseFormat)
-                    ? '.' . $restler->responseFormat->getExtension()
-                    : '.html';
-            static::$url = $restler->getBaseUrl();
-            if (empty(static::$url))
-                static::$url = '';
-            static::$activeTrail = $activeTrail = empty($activeTrail)
-                ? (empty($restler->url) || $restler->url == 'index'
-                    ? static::$root
-                    : $restler->url
-                )
-                : $activeTrail;
-            if (static::$addExtension)
-                static::$extension = isset($restler->responseFormat)
-                    ? '.' . $restler->responseFormat->getExtension()
-                    : '.html';
-            static::addUrls(static::$prepends);
-            $map = Routes::findAll(
-                static::$excludedPaths,
-                array('POST', 'DELETE', 'PUT', 'PATCH'),
-                $restler->getRequestedApiVersion()
-            );
-            foreach ($map as $path => $data) {
-                foreach ($data as $item) {
-                    $access = $item['access'];
-                    $route = $item['route'];
-                    $url = $route['url'];
-                    if ($access && !Text::contains($url, '{')) {
-                        $label = Util::nestedValue(
-                            $route,
-                            'metadata',
-                            CommentParser::$embeddedDataName,
-                            'label'
-                        );
-                        if (!empty($url)) {
-                            $url .= static::$extension;
-                        }
-                        static::add($url, $label);
-                    }
-                }
-            }
-            static::addUrls(static::$appends);
-        } elseif (empty($activeTrail)) {
-            $activeTrail = static::$activeTrail;
-        }
-        $tree = static::$tree;
-        $activeTrail = explode('/', $activeTrail);
-        $nested = & static::nested($tree, $activeTrail);
-        if (is_array($nested)) {
-            $nested['active'] = true;
-        }
-        if (!empty($for)) {
-            $for = explode('/', $for);
-            $tree = static::nested($tree, $for)['children'];
-        }
-        return array_filter($tree);
-    }
+	public static function get($for = '', $activeTrail = null)
+	{
+		if (empty(static::$tree)) {
+			/** @var Restler $restler */
+			$restler = Scope::get('Restler');
+			if (static::$addExtension)
+				static::$extension = isset($restler->responseFormat)
+					? '.' . $restler->responseFormat->getExtension()
+					: '.html';
+			static::$url = $restler->getBaseUrl();
+			if (empty(static::$url))
+				static::$url = '';
+			static::$activeTrail = $activeTrail = empty($activeTrail)
+				? (empty($restler->url) || $restler->url == 'index'
+					? static::$root
+					: $restler->url
+				)
+				: $activeTrail;
+			if (static::$addExtension)
+				static::$extension = isset($restler->responseFormat)
+					? '.' . $restler->responseFormat->getExtension()
+					: '.html';
+			static::addUrls(static::$prepends);
+			$map = Routes::findAll(
+				static::$excludedPaths,
+				array('POST', 'DELETE', 'PUT', 'PATCH'),
+				$restler->getRequestedApiVersion()
+			);
+			foreach ($map as $path => $data) {
+				foreach ($data as $item) {
+					$access = $item['access'];
+					$route = $item['route'];
+					$url = $route['url'];
+					if ($access && !Text::contains($url, '{')) {
+						$label = Util::nestedValue(
+							$route,
+							'metadata',
+							CommentParser::$embeddedDataName,
+							'label'
+						);
+						if (!empty($url)) {
+							$url .= static::$extension;
+						}
+						static::add($url, $label);
+					}
+				}
+			}
+			static::addUrls(static::$appends);
+		} elseif (empty($activeTrail)) {
+			$activeTrail = static::$activeTrail;
+		}
+		$tree = static::$tree;
+		$activeTrail = explode('/', $activeTrail);
+		$nested = & static::nested($tree, $activeTrail);
+		if (is_array($nested)) {
+			$nested['active'] = true;
+		}
+		if (!empty($for)) {
+			$for = explode('/', $for);
+			$tree = static::nested($tree, $for)['children'];
+		}
+		return array_filter($tree);
+	}
 
-    protected static function & nested(array & $tree, array $parts)
-    {
-        if (!empty($parts)) {
-            $part = array_shift($parts);
-            if (empty($tree[$part])) {
-                return $tree[$part];
-            } elseif (empty($parts)) {
-                return static::nested($tree[$part], $parts);
-            } elseif (!empty($tree[$part]['children'])) {
-                return static::nested($tree[$part]['children'], $parts);
-            }
-        } else {
-            return $tree;
-        }
-        $value = null;
-        return $value;
-    }
+	protected static function & nested(array & $tree, array $parts)
+	{
+		if (!empty($parts)) {
+			$part = array_shift($parts);
+			if (empty($tree[$part])) {
+				return $tree[$part];
+			} elseif (empty($parts)) {
+				return static::nested($tree[$part], $parts);
+			} elseif (!empty($tree[$part]['children'])) {
+				return static::nested($tree[$part]['children'], $parts);
+			}
+		} else {
+			return $tree;
+		}
+		$value = null;
+		return $value;
+	}
 
-    public static function addUrls(array $urls)
-    {
-        foreach ($urls as $url => $label) {
-            $trail = null;
-            if (is_array($label)) {
-                if (isset($label['trail'])) {
-                    $trail = $label['trail'];
-                }
-                if (isset($label['url'])) {
-                    $url = $label['url'];
-                    $label = isset($label['label']) ? $label['label'] : null;
-                } else {
-                    $url = current(array_keys($label));
-                    $label = current($label);
-                }
+	public static function addUrls(array $urls)
+	{
+		foreach ($urls as $url => $label) {
+			$trail = null;
+			if (is_array($label)) {
+				if (isset($label['trail'])) {
+					$trail = $label['trail'];
+				}
+				if (isset($label['url'])) {
+					$url = $label['url'];
+					$label = isset($label['label']) ? $label['label'] : null;
+				} else {
+					$url = current(array_keys($label));
+					$label = current($label);
+				}
 
-            }
-            if (is_numeric($url)) {
-                $url = $label;
-                $label = null;
-            }
-            static::add($url, $label, $trail);
-        }
-        return static::$tree;
-    }
+			}
+			if (is_numeric($url)) {
+				$url = $label;
+				$label = null;
+			}
+			static::add($url, $label, $trail);
+		}
+		return static::$tree;
+	}
 
-    public static function add($url, $label = null, $trail = null)
-    {
-        $r = parse_url($url);
-        if (is_null($trail)) {
-            $trail = isset($r['path']) ? $r['path'] : static::$root;
-        }
-        //remove / prefix and / suffixes and any extension
-        $trail = strtok(trim($trail, '/'), '.');
-        $parts = explode('/', $trail);
-        if (count($parts) == 1 && empty($parts[0]))
-            $parts = array(static::$root);
-        if (isset($r['fragment'])) {
-            $parts[] = $r['fragment'];
-            if (is_null($label)) {
-                $label = Text::title($r['fragment']);
-            }
-        }
-        if (empty($r['scheme'])) {
-            //relative url found
-            if (empty($url)) {
-                $label = Text::title(static::$root);
-                $url = static::$url;
-            } else {
-                $url = static::$url . '/' . ltrim($url, '/');
-            }
-        }
-        if (is_null($label)) {
-            $label = Text::title(strtok(end($parts), '.'));
-        }
-        $r['url'] = $url;
-        $r['path'] = $trail;
-        $r['parts'] = $parts;
-        $r['label'] = $label;
-        static::build($r);
-        return $r;
-    }
+	public static function add($url, $label = null, $trail = null)
+	{
+		$r = parse_url($url);
+		if (is_null($trail)) {
+			$trail = isset($r['path']) ? $r['path'] : static::$root;
+		}
+		//remove / prefix and / suffixes and any extension
+		$trail = strtok(trim($trail, '/'), '.');
+		$parts = explode('/', $trail);
+		if (count($parts) == 1 && empty($parts[0]))
+			$parts = array(static::$root);
+		if (isset($r['fragment'])) {
+			$parts[] = $r['fragment'];
+			if (is_null($label)) {
+				$label = Text::title($r['fragment']);
+			}
+		}
+		if (empty($r['scheme'])) {
+			//relative url found
+			if (empty($url)) {
+				$label = Text::title(static::$root);
+				$url = static::$url;
+			} else {
+				$url = static::$url . '/' . ltrim($url, '/');
+			}
+		}
+		if (is_null($label)) {
+			$label = Text::title(strtok(end($parts), '.'));
+		}
+		$r['url'] = $url;
+		$r['path'] = $trail;
+		$r['parts'] = $parts;
+		$r['label'] = $label;
+		static::build($r);
+		return $r;
+	}
 
-    public static function build(array $r)
-    {
-        $p = & static::$tree;
-        $parts = $r['parts'];
-        $last = count($parts) - 1;
-        foreach ($parts as $i => $part) {
-            if ($i == $last) {
-                $p[$part]['text'] = $r['label'];
-                $p[$part]['href'] = $r['url'];
-                $p[$part]['class'] = Text::slug($part);
-                /* dynamically do it at run time instead
+	public static function build(array $r)
+	{
+		$p = & static::$tree;
+		$parts = $r['parts'];
+		$last = count($parts) - 1;
+		foreach ($parts as $i => $part) {
+			if ($i == $last) {
+				$p[$part]['text'] = $r['label'];
+				$p[$part]['href'] = $r['url'];
+				$p[$part]['class'] = Text::slug($part);
+				/* dynamically do it at run time instead
                 if ($r['path'] == static::$activeTrail)
                     $p[$part]['active'] = true;
                 */
-            } elseif (!isset($p[$part])) {
-                $p[$part] = array();
-                $p[$part]['text'] = Text::title($part);
-                $p[$part]['href'] = '#';
-                $p[$part]['children'] = array();
-            }
-            $p = & $p[$part]['children'];
-        }
-    }
+			} elseif (!isset($p[$part])) {
+				$p[$part] = array();
+				$p[$part]['text'] = Text::title($part);
+				$p[$part]['href'] = '#';
+				$p[$part]['children'] = array();
+			}
+			$p = & $p[$part]['children'];
+		}
+	}
 }

Spacing +3 added lines, -3 removed lines

@@ -59,7 +59,7 @@ 
             $restler = Scope::get('Restler');
             if (static::$addExtension)
                 static::$extension = isset($restler->responseFormat)
-                    ? '.' . $restler->responseFormat->getExtension()
+                    ? '.'.$restler->responseFormat->getExtension()
                     : '.html';
             static::$url = $restler->getBaseUrl();
             if (empty(static::$url))
@@ -72,7 +72,7 @@ 
                 : $activeTrail;
             if (static::$addExtension)
                 static::$extension = isset($restler->responseFormat)
-                    ? '.' . $restler->responseFormat->getExtension()
+                    ? '.'.$restler->responseFormat->getExtension()
                     : '.html';
             static::addUrls(static::$prepends);
             $map = Routes::findAll(
@@ -183,7 +183,7 @@ 
                 $label = Text::title(static::$root);
                 $url = static::$url;
             } else {
-                $url = static::$url . '/' . ltrim($url, '/');
+                $url = static::$url.'/'.ltrim($url, '/');
             }
         }
         if (is_null($label)) {

Braces +12 added lines, -8 removed lines

@@ -57,23 +57,26 @@ 
         if (empty(static::$tree)) {
             /** @var Restler $restler */
             $restler = Scope::get('Restler');
-            if (static::$addExtension)
-                static::$extension = isset($restler->responseFormat)
+            if (static::$addExtension) {
+                            static::$extension = isset($restler->responseFormat)
                     ? '.' . $restler->responseFormat->getExtension()
                     : '.html';
+            }
             static::$url = $restler->getBaseUrl();
-            if (empty(static::$url))
-                static::$url = '';
+            if (empty(static::$url)) {
+                            static::$url = '';
+            }
             static::$activeTrail = $activeTrail = empty($activeTrail)
                 ? (empty($restler->url) || $restler->url == 'index'
                     ? static::$root
                     : $restler->url
                 )
                 : $activeTrail;
-            if (static::$addExtension)
-                static::$extension = isset($restler->responseFormat)
+            if (static::$addExtension) {
+                            static::$extension = isset($restler->responseFormat)
                     ? '.' . $restler->responseFormat->getExtension()
                     : '.html';
+            }
             static::addUrls(static::$prepends);
             $map = Routes::findAll(
                 static::$excludedPaths,
@@ -169,8 +172,9 @@ 
         //remove / prefix and / suffixes and any extension
         $trail = strtok(trim($trail, '/'), '.');
         $parts = explode('/', $trail);
-        if (count($parts) == 1 && empty($parts[0]))
-            $parts = array(static::$root);
+        if (count($parts) == 1 && empty($parts[0])) {
+                    $parts = array(static::$root);
+        }
         if (isset($r['fragment'])) {
             $parts[] = $r['fragment'];
             if (is_null($label)) {

htdocs/includes/restler/framework/Luracast/Restler/UI/Forms.php

Indentation +428 added lines, -428 removed lines

@@ -34,453 +34,453 @@
  */
 class Forms implements iFilter
 {
-    const FORM_KEY = 'form_key';
-    public static $filterFormRequestsOnly = false;
+	const FORM_KEY = 'form_key';
+	public static $filterFormRequestsOnly = false;
 
-    public static $excludedPaths = array();
+	public static $excludedPaths = array();
 
-    private static $style;
-    /**
-     * @var bool should we fill up the form using given data?
-     */
-    public static $preFill = true;
-    /**
-     * @var ValidationInfo
-     */
-    public static $validationInfo = null;
-    protected static $inputTypes = array(
-        'hidden',
-        'password',
-        'button',
-        'image',
-        'file',
-        'reset',
-        'submit',
-        'search',
-        'checkbox',
-        'radio',
-        'email',
-        'text',
-        'color',
-        'date',
-        'datetime',
-        'datetime-local',
-        'email',
-        'month',
-        'number',
-        'range',
-        'search',
-        'tel',
-        'time',
-        'url',
-        'week',
-    );
-    protected static $fileUpload = false;
-    private static $key = array();
-    /**
-     * @var ApiMethodInfo;
-     */
-    private static $info;
+	private static $style;
+	/**
+	 * @var bool should we fill up the form using given data?
+	 */
+	public static $preFill = true;
+	/**
+	 * @var ValidationInfo
+	 */
+	public static $validationInfo = null;
+	protected static $inputTypes = array(
+		'hidden',
+		'password',
+		'button',
+		'image',
+		'file',
+		'reset',
+		'submit',
+		'search',
+		'checkbox',
+		'radio',
+		'email',
+		'text',
+		'color',
+		'date',
+		'datetime',
+		'datetime-local',
+		'email',
+		'month',
+		'number',
+		'range',
+		'search',
+		'tel',
+		'time',
+		'url',
+		'week',
+	);
+	protected static $fileUpload = false;
+	private static $key = array();
+	/**
+	 * @var ApiMethodInfo;
+	 */
+	private static $info;
 
-    public static function setStyles(HtmlForm $style)
-    {
-        static::$style = get_class($style);
-    }
+	public static function setStyles(HtmlForm $style)
+	{
+		static::$style = get_class($style);
+	}
 
-    /**
-     * Get the form
-     *
-     * @param string $method   http method to submit the form
-     * @param string $action   relative path from the web root. When set to null
-     *                         it uses the current api method's path
-     * @param bool   $dataOnly if you want to render the form yourself use this
-     *                         option
-     * @param string $prefix   used for adjusting the spacing in front of
-     *                         form elements
-     * @param string $indent   used for adjusting indentation
-     *
-     * @return array|T
-     *
-     * @throws RestException
-     */
-    public static function get($method = 'POST', $action = null, $dataOnly = false, $prefix = '', $indent = '    ')
-    {
-        if (!static::$style) {
-            static::$style = 'Luracast\\Restler\\UI\HtmlForm';
-        }
+	/**
+	 * Get the form
+	 *
+	 * @param string $method   http method to submit the form
+	 * @param string $action   relative path from the web root. When set to null
+	 *                         it uses the current api method's path
+	 * @param bool   $dataOnly if you want to render the form yourself use this
+	 *                         option
+	 * @param string $prefix   used for adjusting the spacing in front of
+	 *                         form elements
+	 * @param string $indent   used for adjusting indentation
+	 *
+	 * @return array|T
+	 *
+	 * @throws RestException
+	 */
+	public static function get($method = 'POST', $action = null, $dataOnly = false, $prefix = '', $indent = '    ')
+	{
+		if (!static::$style) {
+			static::$style = 'Luracast\\Restler\\UI\HtmlForm';
+		}
 
-        try {
-            /** @var Restler $restler */
-            $restler = Scope::get('Restler');
-            if (is_null($action)) {
-                $action = $restler->url;
-            }
+		try {
+			/** @var Restler $restler */
+			$restler = Scope::get('Restler');
+			if (is_null($action)) {
+				$action = $restler->url;
+			}
 
-            $info = $restler->url == $action
-            && Util::getRequestMethod() == $method
-                ? $restler->apiMethodInfo
-                : Routes::find(
-                    trim($action, '/'),
-                    $method,
-                    $restler->getRequestedApiVersion(),
-                    static::$preFill ||
-                    ($restler->requestMethod == $method &&
-                        $restler->url == $action)
-                        ? $restler->getRequestData()
-                        : array()
-                );
+			$info = $restler->url == $action
+			&& Util::getRequestMethod() == $method
+				? $restler->apiMethodInfo
+				: Routes::find(
+					trim($action, '/'),
+					$method,
+					$restler->getRequestedApiVersion(),
+					static::$preFill ||
+					($restler->requestMethod == $method &&
+						$restler->url == $action)
+						? $restler->getRequestData()
+						: array()
+				);
 
-        } catch (RestException $e) {
-            //echo $e->getErrorMessage();
-            $info = false;
-        }
-        if (!$info) {
-            throw new RestException(500, 'invalid action path for form `' . $method . ' ' . $action . '`');
-        }
-        static::$info = $info;
-        $m = $info->metadata;
-        $r = static::fields($dataOnly);
-        if ($method != 'GET' && $method != 'POST') {
-            if (empty(Defaults::$httpMethodOverrideProperty)) {
-                throw new RestException(
-                    500,
-                    'Forms require `Defaults::\$httpMethodOverrideProperty`' .
-                    "for supporting HTTP $method"
-                );
-            }
-            if ($dataOnly) {
-                $r[] = array(
-                    'tag'   => 'input',
-                    'name'  => Defaults::$httpMethodOverrideProperty,
-                    'type'  => 'hidden',
-                    'value' => 'method',
-                );
-            } else {
-                $r[] = T::input()
-                    ->name(Defaults::$httpMethodOverrideProperty)
-                    ->value($method)
-                    ->type('hidden');
-            }
+		} catch (RestException $e) {
+			//echo $e->getErrorMessage();
+			$info = false;
+		}
+		if (!$info) {
+			throw new RestException(500, 'invalid action path for form `' . $method . ' ' . $action . '`');
+		}
+		static::$info = $info;
+		$m = $info->metadata;
+		$r = static::fields($dataOnly);
+		if ($method != 'GET' && $method != 'POST') {
+			if (empty(Defaults::$httpMethodOverrideProperty)) {
+				throw new RestException(
+					500,
+					'Forms require `Defaults::\$httpMethodOverrideProperty`' .
+					"for supporting HTTP $method"
+				);
+			}
+			if ($dataOnly) {
+				$r[] = array(
+					'tag'   => 'input',
+					'name'  => Defaults::$httpMethodOverrideProperty,
+					'type'  => 'hidden',
+					'value' => 'method',
+				);
+			} else {
+				$r[] = T::input()
+					->name(Defaults::$httpMethodOverrideProperty)
+					->value($method)
+					->type('hidden');
+			}
 
-            $method = 'POST';
-        }
-        if (session_id() != '') {
-            $form_key = static::key($method, $action);
-            if ($dataOnly) {
-                $r[] = array(
-                    'tag'   => 'input',
-                    'name'  => static::FORM_KEY,
-                    'type'  => 'hidden',
-                    'value' => 'hidden',
-                );
-            } else {
-                $key = T::input()
-                    ->name(static::FORM_KEY)
-                    ->type('hidden')
-                    ->value($form_key);
-                $r[] = $key;
-            }
-        }
+			$method = 'POST';
+		}
+		if (session_id() != '') {
+			$form_key = static::key($method, $action);
+			if ($dataOnly) {
+				$r[] = array(
+					'tag'   => 'input',
+					'name'  => static::FORM_KEY,
+					'type'  => 'hidden',
+					'value' => 'hidden',
+				);
+			} else {
+				$key = T::input()
+					->name(static::FORM_KEY)
+					->type('hidden')
+					->value($form_key);
+				$r[] = $key;
+			}
+		}
 
-        $s = array(
-            'tag'   => 'button',
-            'type'  => 'submit',
-            'label' =>
-                Util::nestedValue($m, 'return', CommentParser::$embeddedDataName, 'label')
-                    ?: 'Submit'
-        );
+		$s = array(
+			'tag'   => 'button',
+			'type'  => 'submit',
+			'label' =>
+				Util::nestedValue($m, 'return', CommentParser::$embeddedDataName, 'label')
+					?: 'Submit'
+		);
 
-        if (!$dataOnly) {
-            $s = Emmet::make(static::style('submit', $m), $s);
-        }
-        $r[] = $s;
-        $t = array(
-            'action' => $restler->getBaseUrl() . '/' . rtrim($action, '/'),
-            'method' => $method,
-        );
-        if (static::$fileUpload) {
-            static::$fileUpload = false;
-            $t['enctype'] = 'multipart/form-data';
-        }
-        if (isset($m[CommentParser::$embeddedDataName])) {
-            $t += $m[CommentParser::$embeddedDataName];
-        }
-        if (!$dataOnly) {
-            $t = Emmet::make(static::style('form', $m), $t);
-            $t->prefix = $prefix;
-            $t->indent = $indent;
-            $t[] = $r;
-        } else {
-            $t['fields'] = $r;
-        }
-        return $t;
-    }
+		if (!$dataOnly) {
+			$s = Emmet::make(static::style('submit', $m), $s);
+		}
+		$r[] = $s;
+		$t = array(
+			'action' => $restler->getBaseUrl() . '/' . rtrim($action, '/'),
+			'method' => $method,
+		);
+		if (static::$fileUpload) {
+			static::$fileUpload = false;
+			$t['enctype'] = 'multipart/form-data';
+		}
+		if (isset($m[CommentParser::$embeddedDataName])) {
+			$t += $m[CommentParser::$embeddedDataName];
+		}
+		if (!$dataOnly) {
+			$t = Emmet::make(static::style('form', $m), $t);
+			$t->prefix = $prefix;
+			$t->indent = $indent;
+			$t[] = $r;
+		} else {
+			$t['fields'] = $r;
+		}
+		return $t;
+	}
 
-    public static function style($name, array $metadata, $type = '')
-    {
-        if (isset($metadata[CommentParser::$embeddedDataName][$name])) {
-            return $metadata[CommentParser::$embeddedDataName][$name];
-        }
-        $style = static::$style . '::' . $name;
-        $typedStyle = $style . '_' . $type;
-        if (defined($typedStyle)) {
-            return constant($typedStyle);
-        }
-        if (defined($style)) {
-            return constant($style);
-        }
-        return null;
-    }
+	public static function style($name, array $metadata, $type = '')
+	{
+		if (isset($metadata[CommentParser::$embeddedDataName][$name])) {
+			return $metadata[CommentParser::$embeddedDataName][$name];
+		}
+		$style = static::$style . '::' . $name;
+		$typedStyle = $style . '_' . $type;
+		if (defined($typedStyle)) {
+			return constant($typedStyle);
+		}
+		if (defined($style)) {
+			return constant($style);
+		}
+		return null;
+	}
 
-    public static function fields($dataOnly = false)
-    {
-        $m = static::$info->metadata;
-        $params = $m['param'];
-        $values = static::$info->parameters;
-        $r = array();
-        foreach ($params as $k => $p) {
-            $value = Util::nestedValue($values, $k);
-            if (
-                is_scalar($value) ||
-                ($p['type'] == 'array' && is_array($value) && $value == array_values($value)) ||
-                is_object($value) && $p['type'] == get_class($value)
-            ) {
-                $p['value'] = $value;
-            }
-            static::$validationInfo = $v = new ValidationInfo($p);
-            if ($v->from == 'path') {
-                continue;
-            }
-            if (!empty($v->children)) {
-                $t = Emmet::make(static::style('fieldset', $m), array('label' => $v->label));
-                foreach ($v->children as $n => $c) {
-                    $value = Util::nestedValue($v->value, $n);
-                    if (
-                        is_scalar($value) ||
-                        ($c['type'] == 'array' && is_array($value) && $value == array_values($value)) ||
-                        is_object($value) && $c['type'] == get_class($value)
-                    ) {
-                        $c['value'] = $value;
-                    }
-                    static::$validationInfo = $vc = new ValidationInfo($c);
-                    if ($vc->from == 'path') {
-                        continue;
-                    }
-                    $vc->name = $v->name . '[' . $vc->name . ']';
-                    $t [] = static::field($vc, $dataOnly);
-                }
-                $r[] = $t;
-                static::$validationInfo = null;
-            } else {
-                $f = static::field($v, $dataOnly);
-                $r [] = $f;
-            }
-            static::$validationInfo = null;
-        }
-        return $r;
-    }
+	public static function fields($dataOnly = false)
+	{
+		$m = static::$info->metadata;
+		$params = $m['param'];
+		$values = static::$info->parameters;
+		$r = array();
+		foreach ($params as $k => $p) {
+			$value = Util::nestedValue($values, $k);
+			if (
+				is_scalar($value) ||
+				($p['type'] == 'array' && is_array($value) && $value == array_values($value)) ||
+				is_object($value) && $p['type'] == get_class($value)
+			) {
+				$p['value'] = $value;
+			}
+			static::$validationInfo = $v = new ValidationInfo($p);
+			if ($v->from == 'path') {
+				continue;
+			}
+			if (!empty($v->children)) {
+				$t = Emmet::make(static::style('fieldset', $m), array('label' => $v->label));
+				foreach ($v->children as $n => $c) {
+					$value = Util::nestedValue($v->value, $n);
+					if (
+						is_scalar($value) ||
+						($c['type'] == 'array' && is_array($value) && $value == array_values($value)) ||
+						is_object($value) && $c['type'] == get_class($value)
+					) {
+						$c['value'] = $value;
+					}
+					static::$validationInfo = $vc = new ValidationInfo($c);
+					if ($vc->from == 'path') {
+						continue;
+					}
+					$vc->name = $v->name . '[' . $vc->name . ']';
+					$t [] = static::field($vc, $dataOnly);
+				}
+				$r[] = $t;
+				static::$validationInfo = null;
+			} else {
+				$f = static::field($v, $dataOnly);
+				$r [] = $f;
+			}
+			static::$validationInfo = null;
+		}
+		return $r;
+	}
 
-    /**
-     * @param ValidationInfo $p
-     *
-     * @param bool           $dataOnly
-     *
-     * @return array|T
-     */
-    public static function field(ValidationInfo $p, $dataOnly = false)
-    {
-        if (is_string($p->value)) {
-            //prevent XSS attacks
-            $p->value = htmlspecialchars($p->value, ENT_QUOTES | ENT_HTML401, 'UTF-8');
-        }
-        $type = $p->field ?: static::guessFieldType($p);
-        $tag = in_array($type, static::$inputTypes)
-            ? 'input' : $type;
-        $options = array();
-        $name = $p->name;
-        $multiple = null;
-        if ($p->type == 'array' && $p->contentType != 'associative') {
-            $name .= '[]';
-            $multiple = true;
-        }
-        if ($p->choice) {
-            foreach ($p->choice as $i => $choice) {
-                $option = array('name' => $name, 'value' => $choice);
-                $option['text'] = isset($p->rules['select'][$i])
-                    ? $p->rules['select'][$i]
-                    : $choice;
-                if ($choice == $p->value) {
-                    $option['selected'] = true;
-                }
-                $options[] = $option;
-            }
-        } elseif ($p->type == 'boolean' || $p->type == 'bool') {
-            if (Text::beginsWith($type, 'radio') || Text::beginsWith($type, 'select')) {
-                $options[] = array(
-                    'name'  => $p->name,
-                    'text'  => ' Yes ',
-                    'value' => 'true'
-                );
-                $options[] = array(
-                    'name'  => $p->name,
-                    'text'  => ' No ',
-                    'value' => 'false'
-                );
-                if ($p->value || $p->default) {
-                    $options[0]['selected'] = true;
-                }
-            } else { //checkbox
-                $r = array(
-                    'tag'     => $tag,
-                    'name'    => $name,
-                    'type'    => $type,
-                    'label'   => $p->label,
-                    'value'   => 'true',
-                    'default' => $p->default,
-                );
-                $r['text'] = 'Yes';
-                if ($p->default) {
-                    $r['selected'] = true;
-                }
-                if (isset($p->rules)) {
-                    $r += $p->rules;
-                }
-            }
-        }
-        if (empty($r)) {
-            $r = array(
-                'tag'      => $tag,
-                'name'     => $name,
-                'type'     => $type,
-                'label'    => $p->label,
-                'value'    => $p->value,
-                'default'  => $p->default,
-                'options'  => & $options,
-                'multiple' => $multiple,
-            );
-            if (isset($p->rules)) {
-                $r += $p->rules;
-            }
-        }
-        if ($type == 'file') {
-            static::$fileUpload = true;
-            if (empty($r['accept'])) {
-                $r['accept'] = implode(', ', UploadFormat::$allowedMimeTypes);
-            }
-        }
-        if (!empty(Validator::$exceptions[$name]) && static::$info->url == Scope::get('Restler')->url) {
-            $r['error'] = 'has-error';
-            $r['message'] = Validator::$exceptions[$p->name]->getMessage();
-        }
+	/**
+	 * @param ValidationInfo $p
+	 *
+	 * @param bool           $dataOnly
+	 *
+	 * @return array|T
+	 */
+	public static function field(ValidationInfo $p, $dataOnly = false)
+	{
+		if (is_string($p->value)) {
+			//prevent XSS attacks
+			$p->value = htmlspecialchars($p->value, ENT_QUOTES | ENT_HTML401, 'UTF-8');
+		}
+		$type = $p->field ?: static::guessFieldType($p);
+		$tag = in_array($type, static::$inputTypes)
+			? 'input' : $type;
+		$options = array();
+		$name = $p->name;
+		$multiple = null;
+		if ($p->type == 'array' && $p->contentType != 'associative') {
+			$name .= '[]';
+			$multiple = true;
+		}
+		if ($p->choice) {
+			foreach ($p->choice as $i => $choice) {
+				$option = array('name' => $name, 'value' => $choice);
+				$option['text'] = isset($p->rules['select'][$i])
+					? $p->rules['select'][$i]
+					: $choice;
+				if ($choice == $p->value) {
+					$option['selected'] = true;
+				}
+				$options[] = $option;
+			}
+		} elseif ($p->type == 'boolean' || $p->type == 'bool') {
+			if (Text::beginsWith($type, 'radio') || Text::beginsWith($type, 'select')) {
+				$options[] = array(
+					'name'  => $p->name,
+					'text'  => ' Yes ',
+					'value' => 'true'
+				);
+				$options[] = array(
+					'name'  => $p->name,
+					'text'  => ' No ',
+					'value' => 'false'
+				);
+				if ($p->value || $p->default) {
+					$options[0]['selected'] = true;
+				}
+			} else { //checkbox
+				$r = array(
+					'tag'     => $tag,
+					'name'    => $name,
+					'type'    => $type,
+					'label'   => $p->label,
+					'value'   => 'true',
+					'default' => $p->default,
+				);
+				$r['text'] = 'Yes';
+				if ($p->default) {
+					$r['selected'] = true;
+				}
+				if (isset($p->rules)) {
+					$r += $p->rules;
+				}
+			}
+		}
+		if (empty($r)) {
+			$r = array(
+				'tag'      => $tag,
+				'name'     => $name,
+				'type'     => $type,
+				'label'    => $p->label,
+				'value'    => $p->value,
+				'default'  => $p->default,
+				'options'  => & $options,
+				'multiple' => $multiple,
+			);
+			if (isset($p->rules)) {
+				$r += $p->rules;
+			}
+		}
+		if ($type == 'file') {
+			static::$fileUpload = true;
+			if (empty($r['accept'])) {
+				$r['accept'] = implode(', ', UploadFormat::$allowedMimeTypes);
+			}
+		}
+		if (!empty(Validator::$exceptions[$name]) && static::$info->url == Scope::get('Restler')->url) {
+			$r['error'] = 'has-error';
+			$r['message'] = Validator::$exceptions[$p->name]->getMessage();
+		}
 
-        if (true === $p->required) {
-            $r['required'] = 'required';
-        }
-        if (isset($p->rules['autofocus'])) {
-            $r['autofocus'] = 'autofocus';
-        }
-        /*
+		if (true === $p->required) {
+			$r['required'] = 'required';
+		}
+		if (isset($p->rules['autofocus'])) {
+			$r['autofocus'] = 'autofocus';
+		}
+		/*
         echo "<pre>";
         print_r($r);
         echo "</pre>";
         */
-        if ($dataOnly) {
-            return $r;
-        }
-        if (isset($p->rules['form'])) {
-            return Emmet::make($p->rules['form'], $r);
-        }
-        $m = static::$info->metadata;
-        $t = Emmet::make(static::style($type, $m, $p->type) ?: static::style($tag, $m, $p->type), $r);
-        return $t;
-    }
+		if ($dataOnly) {
+			return $r;
+		}
+		if (isset($p->rules['form'])) {
+			return Emmet::make($p->rules['form'], $r);
+		}
+		$m = static::$info->metadata;
+		$t = Emmet::make(static::style($type, $m, $p->type) ?: static::style($tag, $m, $p->type), $r);
+		return $t;
+	}
 
-    protected static function guessFieldType(ValidationInfo $p, $type = 'type')
-    {
-        if (in_array($p->$type, static::$inputTypes)) {
-            return $p->$type;
-        }
-        if ($p->choice) {
-            return $p->type == 'array' ? 'checkbox' : 'select';
-        }
-        switch ($p->$type) {
-            case 'boolean':
-                return 'radio';
-            case 'int':
-            case 'number':
-            case 'float':
-                return 'number';
-            case 'array':
-                return static::guessFieldType($p, 'contentType');
-        }
-        if ($p->name == 'password') {
-            return 'password';
-        }
-        return 'text';
-    }
+	protected static function guessFieldType(ValidationInfo $p, $type = 'type')
+	{
+		if (in_array($p->$type, static::$inputTypes)) {
+			return $p->$type;
+		}
+		if ($p->choice) {
+			return $p->type == 'array' ? 'checkbox' : 'select';
+		}
+		switch ($p->$type) {
+			case 'boolean':
+				return 'radio';
+			case 'int':
+			case 'number':
+			case 'float':
+				return 'number';
+			case 'array':
+				return static::guessFieldType($p, 'contentType');
+		}
+		if ($p->name == 'password') {
+			return 'password';
+		}
+		return 'text';
+	}
 
-    /**
-     * Get the form key
-     *
-     * @param string $method   http method for form key
-     * @param string $action   relative path from the web root. When set to null
-     *                         it uses the current api method's path
-     *
-     * @return string generated form key
-     */
-    public static function key($method = 'POST', $action = null)
-    {
-        if (is_null($action)) {
-            $action = Scope::get('Restler')->url;
-        }
-        $target = "$method $action";
-        if (empty(static::$key[$target])) {
-            static::$key[$target] = md5($target . User::getIpAddress() . uniqid(mt_rand()));
-        }
-        $_SESSION[static::FORM_KEY] = static::$key;
-        return static::$key[$target];
-    }
+	/**
+	 * Get the form key
+	 *
+	 * @param string $method   http method for form key
+	 * @param string $action   relative path from the web root. When set to null
+	 *                         it uses the current api method's path
+	 *
+	 * @return string generated form key
+	 */
+	public static function key($method = 'POST', $action = null)
+	{
+		if (is_null($action)) {
+			$action = Scope::get('Restler')->url;
+		}
+		$target = "$method $action";
+		if (empty(static::$key[$target])) {
+			static::$key[$target] = md5($target . User::getIpAddress() . uniqid(mt_rand()));
+		}
+		$_SESSION[static::FORM_KEY] = static::$key;
+		return static::$key[$target];
+	}
 
-    /**
-     * Access verification method.
-     *
-     * API access will be denied when this method returns false
-     *
-     * @return boolean true when api access is allowed false otherwise
-     *
-     * @throws RestException 403 security violation
-     */
-    public function __isAllowed()
-    {
-        if (session_id() == '') {
-            session_start();
-        }
-        /** @var Restler $restler */
-        $restler = $this->restler;
-        $url = $restler->url;
-        foreach (static::$excludedPaths as $exclude) {
-            if (empty($exclude)) {
-                if ($url == $exclude) {
-                    return true;
-                }
-            } elseif (Text::beginsWith($url, $exclude)) {
-                return true;
-            }
-        }
-        $check = static::$filterFormRequestsOnly
-            ? $restler->requestFormat instanceof UrlEncodedFormat || $restler->requestFormat instanceof UploadFormat
-            : true;
-        if (!empty($_POST) && $check) {
-            if (
-                isset($_POST[static::FORM_KEY]) &&
-                ($target = Util::getRequestMethod() . ' ' . $restler->url) &&
-                isset($_SESSION[static::FORM_KEY][$target]) &&
-                $_POST[static::FORM_KEY] == $_SESSION[static::FORM_KEY][$target]
-            ) {
-                return true;
-            }
-            throw new RestException(403, 'Insecure form submission');
-        }
-        return true;
-    }
+	/**
+	 * Access verification method.
+	 *
+	 * API access will be denied when this method returns false
+	 *
+	 * @return boolean true when api access is allowed false otherwise
+	 *
+	 * @throws RestException 403 security violation
+	 */
+	public function __isAllowed()
+	{
+		if (session_id() == '') {
+			session_start();
+		}
+		/** @var Restler $restler */
+		$restler = $this->restler;
+		$url = $restler->url;
+		foreach (static::$excludedPaths as $exclude) {
+			if (empty($exclude)) {
+				if ($url == $exclude) {
+					return true;
+				}
+			} elseif (Text::beginsWith($url, $exclude)) {
+				return true;
+			}
+		}
+		$check = static::$filterFormRequestsOnly
+			? $restler->requestFormat instanceof UrlEncodedFormat || $restler->requestFormat instanceof UploadFormat
+			: true;
+		if (!empty($_POST) && $check) {
+			if (
+				isset($_POST[static::FORM_KEY]) &&
+				($target = Util::getRequestMethod() . ' ' . $restler->url) &&
+				isset($_SESSION[static::FORM_KEY][$target]) &&
+				$_POST[static::FORM_KEY] == $_SESSION[static::FORM_KEY][$target]
+			) {
+				return true;
+			}
+			throw new RestException(403, 'Insecure form submission');
+		}
+		return true;
+	}
 }

Spacing +8 added lines, -8 removed lines

@@ -135,7 +135,7 @@ 
             $info = false;
         }
         if (!$info) {
-            throw new RestException(500, 'invalid action path for form `' . $method . ' ' . $action . '`');
+            throw new RestException(500, 'invalid action path for form `'.$method.' '.$action.'`');
         }
         static::$info = $info;
         $m = $info->metadata;
@@ -144,7 +144,7 @@ 
             if (empty(Defaults::$httpMethodOverrideProperty)) {
                 throw new RestException(
                     500,
-                    'Forms require `Defaults::\$httpMethodOverrideProperty`' .
+                    'Forms require `Defaults::\$httpMethodOverrideProperty`'.
                     "for supporting HTTP $method"
                 );
             }
@@ -195,7 +195,7 @@ 
         }
         $r[] = $s;
         $t = array(
-            'action' => $restler->getBaseUrl() . '/' . rtrim($action, '/'),
+            'action' => $restler->getBaseUrl().'/'.rtrim($action, '/'),
             'method' => $method,
         );
         if (static::$fileUpload) {
@@ -221,8 +221,8 @@ 
         if (isset($metadata[CommentParser::$embeddedDataName][$name])) {
             return $metadata[CommentParser::$embeddedDataName][$name];
         }
-        $style = static::$style . '::' . $name;
-        $typedStyle = $style . '_' . $type;
+        $style = static::$style.'::'.$name;
+        $typedStyle = $style.'_'.$type;
         if (defined($typedStyle)) {
             return constant($typedStyle);
         }
@@ -266,7 +266,7 @@ 
                     if ($vc->from == 'path') {
                         continue;
                     }
-                    $vc->name = $v->name . '[' . $vc->name . ']';
+                    $vc->name = $v->name.'['.$vc->name.']';
                     $t [] = static::field($vc, $dataOnly);
                 }
                 $r[] = $t;
@@ -435,7 +435,7 @@ 
         }
         $target = "$method $action";
         if (empty(static::$key[$target])) {
-            static::$key[$target] = md5($target . User::getIpAddress() . uniqid(mt_rand()));
+            static::$key[$target] = md5($target.User::getIpAddress().uniqid(mt_rand()));
         }
         $_SESSION[static::FORM_KEY] = static::$key;
         return static::$key[$target];
@@ -473,7 +473,7 @@ 
         if (!empty($_POST) && $check) {
             if (
                 isset($_POST[static::FORM_KEY]) &&
-                ($target = Util::getRequestMethod() . ' ' . $restler->url) &&
+                ($target = Util::getRequestMethod().' '.$restler->url) &&
                 isset($_SESSION[static::FORM_KEY][$target]) &&
                 $_POST[static::FORM_KEY] == $_SESSION[static::FORM_KEY][$target]
             ) {

htdocs/includes/restler/framework/Luracast/Restler/UI/Emmet.php

Indentation +355 added lines, -355 removed lines

@@ -12,367 +12,367 @@ 
  */
 class Emmet
 {
-    const DELIMITERS = '.#*>+^[=" ]{$@-#}';
+	const DELIMITERS = '.#*>+^[=" ]{$@-#}';
 
-    /**
-     * Create the needed tag hierarchy from emmet string
-     *
-     * @param string       $string
-     *
-     * @param array|string $data
-     *
-     * @return array|T
-     */
-    public static function make($string, $data = null)
-    {
-        if (!strlen($string))
-            return array();
+	/**
+	 * Create the needed tag hierarchy from emmet string
+	 *
+	 * @param string       $string
+	 *
+	 * @param array|string $data
+	 *
+	 * @return array|T
+	 */
+	public static function make($string, $data = null)
+	{
+		if (!strlen($string))
+			return array();
 
-        $implicitTag =
-            function () use (& $tag) {
-                if (empty($tag->tag)) {
-                    switch ($tag->parent->tag) {
-                        case 'ul':
-                        case 'ol':
-                            $tag->tag = 'li';
-                            break;
-                        case 'em':
-                            $tag->tag = 'span';
-                            break;
-                        case 'table':
-                        case 'tbody':
-                        case 'thead':
-                        case 'tfoot':
-                            $tag->tag = 'tr';
-                            break;
-                        case 'tr':
-                            $tag->tag = 'td';
-                            break;
-                        case 'select':
-                        case 'optgroup':
-                            $tag->tag = 'option';
-                            break;
-                        default:
-                            $tag->tag = 'div';
-                    }
-                }
-            };
+		$implicitTag =
+			function () use (& $tag) {
+				if (empty($tag->tag)) {
+					switch ($tag->parent->tag) {
+						case 'ul':
+						case 'ol':
+							$tag->tag = 'li';
+							break;
+						case 'em':
+							$tag->tag = 'span';
+							break;
+						case 'table':
+						case 'tbody':
+						case 'thead':
+						case 'tfoot':
+							$tag->tag = 'tr';
+							break;
+						case 'tr':
+							$tag->tag = 'td';
+							break;
+						case 'select':
+						case 'optgroup':
+							$tag->tag = 'option';
+							break;
+						default:
+							$tag->tag = 'div';
+					}
+				}
+			};
 
-        $parseText =
-            function (
-                $text, $round, $total, $data, $delimiter = null
-            )
-            use (
-                & $tokens, & $tag
-            ) {
-                $digits = 0;
-                if ($delimiter == null)
-                    $delimiter = array(
-                        '.' => true,
-                        '#' => true,
-                        '*' => true,
-                        '>' => true,
-                        '+' => true,
-                        '^' => true,
-                        '[' => true,
-                        ']' => true,
-                        '=' => true,
-                    );
-                while (!empty($tokens) &&
-                    !isset($delimiter[$t = array_shift($tokens)])) {
-                    while ('$' === $t) {
-                        $digits++;
-                        $t = array_shift($tokens);
-                    }
-                    if ($digits) {
-                        $negative = false;
-                        $offset = 0;
-                        if ('@' == $t) {
-                            if ('-' == ($t = array_shift($tokens))) {
-                                $negative = true;
-                                if (is_numeric(reset($tokens))) {
-                                    $offset = array_shift($tokens);
-                                }
-                            } elseif (is_numeric($t)) {
-                                $offset = $t;
-                            } else {
-                                array_unshift($tokens, $t);
-                            }
-                        } elseif ('#' == ($h = array_shift($tokens))) {
-                            if (!empty($t)) {
-                                $data = Util::nestedValue($data, $t);
-                                if (is_null($data)) {
-                                    return null;
-                                }
-                            }
-                            if (is_numeric($data)) {
-                                $text .= sprintf("%0{$digits}d", (int)$data);
-                            } elseif (is_string($data)) {
-                                $text .= $data;
-                            }
-                            $digits = 0;
-                            continue;
-                        } else {
-                            array_unshift($tokens, $t, $h);
-                        }
-                        if ($negative) {
-                            $n = $total + 1 - $round + $offset;
-                        } else {
-                            $n = $round + $offset;
-                        }
-                        $text .= sprintf("%0{$digits}d", $n);
-                        $digits = 0;
-                    } else {
-                        $text .= $t;
-                    }
-                }
-                if (isset($t))
-                    array_unshift($tokens, $t);
-                return $text;
-            };
+		$parseText =
+			function (
+				$text, $round, $total, $data, $delimiter = null
+			)
+			use (
+				& $tokens, & $tag
+			) {
+				$digits = 0;
+				if ($delimiter == null)
+					$delimiter = array(
+						'.' => true,
+						'#' => true,
+						'*' => true,
+						'>' => true,
+						'+' => true,
+						'^' => true,
+						'[' => true,
+						']' => true,
+						'=' => true,
+					);
+				while (!empty($tokens) &&
+					!isset($delimiter[$t = array_shift($tokens)])) {
+					while ('$' === $t) {
+						$digits++;
+						$t = array_shift($tokens);
+					}
+					if ($digits) {
+						$negative = false;
+						$offset = 0;
+						if ('@' == $t) {
+							if ('-' == ($t = array_shift($tokens))) {
+								$negative = true;
+								if (is_numeric(reset($tokens))) {
+									$offset = array_shift($tokens);
+								}
+							} elseif (is_numeric($t)) {
+								$offset = $t;
+							} else {
+								array_unshift($tokens, $t);
+							}
+						} elseif ('#' == ($h = array_shift($tokens))) {
+							if (!empty($t)) {
+								$data = Util::nestedValue($data, $t);
+								if (is_null($data)) {
+									return null;
+								}
+							}
+							if (is_numeric($data)) {
+								$text .= sprintf("%0{$digits}d", (int)$data);
+							} elseif (is_string($data)) {
+								$text .= $data;
+							}
+							$digits = 0;
+							continue;
+						} else {
+							array_unshift($tokens, $t, $h);
+						}
+						if ($negative) {
+							$n = $total + 1 - $round + $offset;
+						} else {
+							$n = $round + $offset;
+						}
+						$text .= sprintf("%0{$digits}d", $n);
+						$digits = 0;
+					} else {
+						$text .= $t;
+					}
+				}
+				if (isset($t))
+					array_unshift($tokens, $t);
+				return $text;
+			};
 
-        $parseAttributes =
-            function (Callable $self, $round, $total, $data)
-            use (& $tokens, & $tag, $parseText) {
-                $a = $parseText(
-                    '', $round, $total, $data
-                );
-                if (is_null($a))
-                    return;
-                if ('=' == ($v = array_shift($tokens))) {
-                    //value
-                    if ('"' == ($v = array_shift($tokens))) {
-                        $text = '';
-                        $tag->$a($parseText(
-                            $text, $round, $total, $data,
-                            array('"' => true)
-                        ));
-                    } else {
-                        array_unshift($tokens, $v);
-                        $text = '';
-                        $tag->$a($parseText(
-                            $text, $round, $total, $data,
-                            array(' ' => true, ']' => true)
-                        ));
-                    }
-                    if (' ' == ($v = array_shift($tokens))) {
-                        $self($self, $round, $total, $data);
-                    }
-                } elseif (']' == $v) {
-                    //end
-                    $tag->$a('');
-                    return;
-                } elseif (' ' == $v) {
-                    $tag->$a('');
-                    $self($self, $round, $total, $data);
-                }
-            };
+		$parseAttributes =
+			function (Callable $self, $round, $total, $data)
+			use (& $tokens, & $tag, $parseText) {
+				$a = $parseText(
+					'', $round, $total, $data
+				);
+				if (is_null($a))
+					return;
+				if ('=' == ($v = array_shift($tokens))) {
+					//value
+					if ('"' == ($v = array_shift($tokens))) {
+						$text = '';
+						$tag->$a($parseText(
+							$text, $round, $total, $data,
+							array('"' => true)
+						));
+					} else {
+						array_unshift($tokens, $v);
+						$text = '';
+						$tag->$a($parseText(
+							$text, $round, $total, $data,
+							array(' ' => true, ']' => true)
+						));
+					}
+					if (' ' == ($v = array_shift($tokens))) {
+						$self($self, $round, $total, $data);
+					}
+				} elseif (']' == $v) {
+					//end
+					$tag->$a('');
+					return;
+				} elseif (' ' == $v) {
+					$tag->$a('');
+					$self($self, $round, $total, $data);
+				}
+			};
 
-        $tokens = static::tokenize($string);
-        $tag = new T(array_shift($tokens));
-        $parent = $root = new T;
+		$tokens = static::tokenize($string);
+		$tag = new T(array_shift($tokens));
+		$parent = $root = new T;
 
-        $parse =
-            function (
-                Callable $self, $round = 1, $total = 1
-            )
-            use (
-                & $tokens, & $parent, & $tag, & $data,
-                $parseAttributes, $implicitTag, $parseText
-            ) {
-                $offsetTokens = null;
-                $parent[] = $tag;
-                $isInChild = false;
-                while ($tokens) {
-                    switch (array_shift($tokens)) {
-                        //class
-                        case '.':
-                            $offsetTokens = array_values($tokens);
-                            array_unshift($offsetTokens, '.');
-                            $implicitTag();
-                            $e = array_filter(explode(' ', $tag->class));
-                            $e[] = $parseText('', $round, $total, $data);
-                            $tag->class(implode(' ', array_unique($e)));
-                            break;
-                        //id
-                        case '#':
-                            $offsetTokens = array_values($tokens);
-                            array_unshift($offsetTokens, '#');
-                            $implicitTag();
-                            $tag->id(
-                                $parseText(
-                                    array_shift($tokens), $round, $total, $data
-                                )
-                            );
-                            break;
-                        //attributes
-                        case '[':
-                            $offsetTokens = array_values($tokens);
-                            array_unshift($offsetTokens, '[');
-                            $implicitTag();
-                            $parseAttributes(
-                                $parseAttributes, $round, $total, $data
-                            );
-                            break;
-                        //child
-                        case '{':
-                            $text = '';
-                            $tag[] = $parseText(
-                                $text, $round, $total, $data, array('}' => true)
-                            );
-                            break;
-                        case '>':
-                            $isInChild = true;
-                            $offsetTokens = null;
-                            if ('{' == ($t = array_shift($tokens))) {
-                                array_unshift($tokens, $t);
-                                $child = new T();
-                                $tag[] = $child;
-                                $parent = $tag;
-                                $tag = $child;
-                            } elseif ('[' == $t) {
-                                array_unshift($tokens, $t);
-                            } else {
-                                $child = new T($t);
-                                $tag[] = $child;
-                                $parent = $tag;
-                                $tag = $child;
-                            }
-                            break;
-                        //sibling
-                        case '+':
-                            $offsetTokens = null;
-                            if (!$isInChild && $round != $total) {
-                                $tokens = array();
-                                break;
-                            }
-                            if ('{' == ($t = array_shift($tokens))) {
-                                $tag = $tag->parent;
-                                array_unshift($tokens, $t);
-                                break;
-                            } elseif ('[' == $t) {
-                                array_unshift($tokens, $t);
-                            } else {
-                                $child = new T($t);
-                                $tag = $tag->parent;
-                                $tag[] = $child;
-                                $tag = $child;
-                            }
-                            break;
-                        //sibling of parent
-                        case '^':
-                            if ($round != $total) {
-                                $tokens = array();
-                                break;
-                            }
-                            $tag = $tag->parent;
-                            if ($tag->parent)
-                                $tag = $tag->parent;
-                            while ('^' == ($t = array_shift($tokens))) {
-                                if ($tag->parent)
-                                    $tag = $tag->parent;
-                            }
-                            $child = new T($t);
-                            $tag[] = $child;
-                            $tag = $child;
-                            break;
-                        //clone
-                        case '*':
-                            $times = array_shift($tokens);
-                            $removeCount = 2;
-                            $delimiter = array(
-                                '.' => true,
-                                '#' => true,
-                                '*' => true,
-                                '>' => true,
-                                '+' => true,
-                                '^' => true,
-                                '[' => true,
-                                ']' => true,
-                                '=' => true,
-                            );
-                            if (!is_numeric($times)) {
-                                if (is_string($times)) {
-                                    if (!isset($delimiter[$times])) {
-                                        $data = Util::nestedValue($data, $times)
-                                            ? : $data;
-                                    } else {
-                                        array_unshift($tokens, $times);
-                                        $removeCount = 1;
-                                    }
-                                }
-                                $indexed = array_values($data);
-                                $times = is_array($data) && $indexed == $data
-                                    ? count($data) : 0;
-                            }
-                            $source = $tag;
-                            if (!empty($offsetTokens)) {
-                                if (false !== strpos($source->class, ' ')) {
-                                    $class = explode(' ', $source->class);
-                                    array_pop($class);
-                                    $class = implode(' ', $class);
-                                } else {
-                                    $class = null;
-                                }
-                                $tag->class($class);
-                                $star = array_search('*', $offsetTokens);
-                                array_splice($offsetTokens, $star, $removeCount);
-                                $remainingTokens = $offsetTokens;
-                            } else {
-                                $remainingTokens = $tokens;
-                            }
-                            $source->parent = null;
-                            $sourceData = $data;
-                            $currentParent = $parent;
-                            for ($i = 1; $i <= $times; $i++) {
-                                $tag = clone $source;
-                                $parent = $currentParent;
-                                $data = is_array($sourceData)
-                                && isset($sourceData[$i - 1])
-                                    ? $sourceData[$i - 1]
-                                    : @(string)$sourceData;
-                                $tokens = array_values($remainingTokens);
-                                $self($self, $i, $times);
-                            }
-                            $round = 1;
-                            $offsetTokens = null;
-                            $tag = $source;
-                            $tokens = array(); //$remainingTokens;
-                            break;
-                    }
-                }
-            };
-        $parse($parse);
-        return count($root) == 1 ? $root[0] : $root;
-    }
+		$parse =
+			function (
+				Callable $self, $round = 1, $total = 1
+			)
+			use (
+				& $tokens, & $parent, & $tag, & $data,
+				$parseAttributes, $implicitTag, $parseText
+			) {
+				$offsetTokens = null;
+				$parent[] = $tag;
+				$isInChild = false;
+				while ($tokens) {
+					switch (array_shift($tokens)) {
+						//class
+						case '.':
+							$offsetTokens = array_values($tokens);
+							array_unshift($offsetTokens, '.');
+							$implicitTag();
+							$e = array_filter(explode(' ', $tag->class));
+							$e[] = $parseText('', $round, $total, $data);
+							$tag->class(implode(' ', array_unique($e)));
+							break;
+						//id
+						case '#':
+							$offsetTokens = array_values($tokens);
+							array_unshift($offsetTokens, '#');
+							$implicitTag();
+							$tag->id(
+								$parseText(
+									array_shift($tokens), $round, $total, $data
+								)
+							);
+							break;
+						//attributes
+						case '[':
+							$offsetTokens = array_values($tokens);
+							array_unshift($offsetTokens, '[');
+							$implicitTag();
+							$parseAttributes(
+								$parseAttributes, $round, $total, $data
+							);
+							break;
+						//child
+						case '{':
+							$text = '';
+							$tag[] = $parseText(
+								$text, $round, $total, $data, array('}' => true)
+							);
+							break;
+						case '>':
+							$isInChild = true;
+							$offsetTokens = null;
+							if ('{' == ($t = array_shift($tokens))) {
+								array_unshift($tokens, $t);
+								$child = new T();
+								$tag[] = $child;
+								$parent = $tag;
+								$tag = $child;
+							} elseif ('[' == $t) {
+								array_unshift($tokens, $t);
+							} else {
+								$child = new T($t);
+								$tag[] = $child;
+								$parent = $tag;
+								$tag = $child;
+							}
+							break;
+						//sibling
+						case '+':
+							$offsetTokens = null;
+							if (!$isInChild && $round != $total) {
+								$tokens = array();
+								break;
+							}
+							if ('{' == ($t = array_shift($tokens))) {
+								$tag = $tag->parent;
+								array_unshift($tokens, $t);
+								break;
+							} elseif ('[' == $t) {
+								array_unshift($tokens, $t);
+							} else {
+								$child = new T($t);
+								$tag = $tag->parent;
+								$tag[] = $child;
+								$tag = $child;
+							}
+							break;
+						//sibling of parent
+						case '^':
+							if ($round != $total) {
+								$tokens = array();
+								break;
+							}
+							$tag = $tag->parent;
+							if ($tag->parent)
+								$tag = $tag->parent;
+							while ('^' == ($t = array_shift($tokens))) {
+								if ($tag->parent)
+									$tag = $tag->parent;
+							}
+							$child = new T($t);
+							$tag[] = $child;
+							$tag = $child;
+							break;
+						//clone
+						case '*':
+							$times = array_shift($tokens);
+							$removeCount = 2;
+							$delimiter = array(
+								'.' => true,
+								'#' => true,
+								'*' => true,
+								'>' => true,
+								'+' => true,
+								'^' => true,
+								'[' => true,
+								']' => true,
+								'=' => true,
+							);
+							if (!is_numeric($times)) {
+								if (is_string($times)) {
+									if (!isset($delimiter[$times])) {
+										$data = Util::nestedValue($data, $times)
+											? : $data;
+									} else {
+										array_unshift($tokens, $times);
+										$removeCount = 1;
+									}
+								}
+								$indexed = array_values($data);
+								$times = is_array($data) && $indexed == $data
+									? count($data) : 0;
+							}
+							$source = $tag;
+							if (!empty($offsetTokens)) {
+								if (false !== strpos($source->class, ' ')) {
+									$class = explode(' ', $source->class);
+									array_pop($class);
+									$class = implode(' ', $class);
+								} else {
+									$class = null;
+								}
+								$tag->class($class);
+								$star = array_search('*', $offsetTokens);
+								array_splice($offsetTokens, $star, $removeCount);
+								$remainingTokens = $offsetTokens;
+							} else {
+								$remainingTokens = $tokens;
+							}
+							$source->parent = null;
+							$sourceData = $data;
+							$currentParent = $parent;
+							for ($i = 1; $i <= $times; $i++) {
+								$tag = clone $source;
+								$parent = $currentParent;
+								$data = is_array($sourceData)
+								&& isset($sourceData[$i - 1])
+									? $sourceData[$i - 1]
+									: @(string)$sourceData;
+								$tokens = array_values($remainingTokens);
+								$self($self, $i, $times);
+							}
+							$round = 1;
+							$offsetTokens = null;
+							$tag = $source;
+							$tokens = array(); //$remainingTokens;
+							break;
+					}
+				}
+			};
+		$parse($parse);
+		return count($root) == 1 ? $root[0] : $root;
+	}
 
-    public static function tokenize($string)
-    {
-        $r = array();
-        $f = strtok($string, static::DELIMITERS);
-        $pos = 0;
-        do {
-            $start = $pos;
-            $pos = strpos($string, $f, $start);
-            $tokens = array();
-            for ($i = $start; $i < $pos; $i++) {
-                $token = $string[$i];
-                if (('#' == $token || '.' == $token) &&
-                    (!empty($tokens) || $i == 0)
-                ) {
-                    $r[] = '';
-                }
-                $r[] = $tokens[] = $token;
-            }
-            $pos += strlen($f);
-            $r[] = $f;
-        } while (false != ($f = strtok(static::DELIMITERS)));
-        for ($i = $pos; $i < strlen($string); $i++) {
-            $token = $string[$i];
-            $r[] = $tokens[] = $token;
-        }
-        return $r;
-        /* sample output produced by ".row*3>.col*3"
+	public static function tokenize($string)
+	{
+		$r = array();
+		$f = strtok($string, static::DELIMITERS);
+		$pos = 0;
+		do {
+			$start = $pos;
+			$pos = strpos($string, $f, $start);
+			$tokens = array();
+			for ($i = $start; $i < $pos; $i++) {
+				$token = $string[$i];
+				if (('#' == $token || '.' == $token) &&
+					(!empty($tokens) || $i == 0)
+				) {
+					$r[] = '';
+				}
+				$r[] = $tokens[] = $token;
+			}
+			$pos += strlen($f);
+			$r[] = $f;
+		} while (false != ($f = strtok(static::DELIMITERS)));
+		for ($i = $pos; $i < strlen($string); $i++) {
+			$token = $string[$i];
+			$r[] = $tokens[] = $token;
+		}
+		return $r;
+		/* sample output produced by ".row*3>.col*3"
         [0] => div
         [1] => .
         [2] => row
@@ -385,5 +385,5 @@ 
         [9] => *
         [10] => 4
          */
-    }
+	}
 }
\ No newline at end of file

Spacing +7 added lines, -7 removed lines

@@ -29,7 +29,7 @@ 
             return array();
 
         $implicitTag =
-            function () use (& $tag) {
+            function() use (& $tag) {
                 if (empty($tag->tag)) {
                     switch ($tag->parent->tag) {
                         case 'ul':
@@ -59,7 +59,7 @@ 
             };
 
         $parseText =
-            function (
+            function(
                 $text, $round, $total, $data, $delimiter = null
             )
             use (
@@ -106,7 +106,7 @@ 
                                 }
                             }
                             if (is_numeric($data)) {
-                                $text .= sprintf("%0{$digits}d", (int)$data);
+                                $text .= sprintf("%0{$digits}d", (int) $data);
                             } elseif (is_string($data)) {
                                 $text .= $data;
                             }
@@ -132,7 +132,7 @@ 
             };
 
         $parseAttributes =
-            function (Callable $self, $round, $total, $data)
+            function(Callable $self, $round, $total, $data)
             use (& $tokens, & $tag, $parseText) {
                 $a = $parseText(
                     '', $round, $total, $data
@@ -173,7 +173,7 @@ 
         $parent = $root = new T;
 
         $parse =
-            function (
+            function(
                 Callable $self, $round = 1, $total = 1
             )
             use (
@@ -295,7 +295,7 @@ 
                                 if (is_string($times)) {
                                     if (!isset($delimiter[$times])) {
                                         $data = Util::nestedValue($data, $times)
-                                            ? : $data;
+                                            ?: $data;
                                     } else {
                                         array_unshift($tokens, $times);
                                         $removeCount = 1;
@@ -330,7 +330,7 @@ 
                                 $data = is_array($sourceData)
                                 && isset($sourceData[$i - 1])
                                     ? $sourceData[$i - 1]
-                                    : @(string)$sourceData;
+                                    : @(string) $sourceData;
                                 $tokens = array_values($remainingTokens);
                                 $self($self, $i, $times);
                             }

Braces +18 added lines, -12 removed lines

@@ -25,8 +25,9 @@ 
      */
     public static function make($string, $data = null)
     {
-        if (!strlen($string))
-            return array();
+        if (!strlen($string)) {
+                    return array();
+        }
 
         $implicitTag =
             function () use (& $tag) {
@@ -66,8 +67,8 @@ 
                 & $tokens, & $tag
             ) {
                 $digits = 0;
-                if ($delimiter == null)
-                    $delimiter = array(
+                if ($delimiter == null) {
+                                    $delimiter = array(
                         '.' => true,
                         '#' => true,
                         '*' => true,
@@ -78,6 +79,7 @@ 
                         ']' => true,
                         '=' => true,
                     );
+                }
                 while (!empty($tokens) &&
                     !isset($delimiter[$t = array_shift($tokens)])) {
                     while ('$' === $t) {
@@ -126,8 +128,9 @@ 
                         $text .= $t;
                     }
                 }
-                if (isset($t))
-                    array_unshift($tokens, $t);
+                if (isset($t)) {
+                                    array_unshift($tokens, $t);
+                }
                 return $text;
             };
 
@@ -137,8 +140,9 @@ 
                 $a = $parseText(
                     '', $round, $total, $data
                 );
-                if (is_null($a))
-                    return;
+                if (is_null($a)) {
+                                    return;
+                }
                 if ('=' == ($v = array_shift($tokens))) {
                     //value
                     if ('"' == ($v = array_shift($tokens))) {
@@ -266,11 +270,13 @@ 
                                 break;
                             }
                             $tag = $tag->parent;
-                            if ($tag->parent)
-                                $tag = $tag->parent;
+                            if ($tag->parent) {
+                                                            $tag = $tag->parent;
+                            }
                             while ('^' == ($t = array_shift($tokens))) {
-                                if ($tag->parent)
-                                    $tag = $tag->parent;
+                                if ($tag->parent) {
+                                                                    $tag = $tag->parent;
+                                }
                             }
                             $child = new T($t);
                             $tag[] = $child;

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

@@ -132,7 +132,7 @@ 
             };
 
         $parseAttributes =
-            function (Callable $self, $round, $total, $data)
+            function (callable $self, $round, $total, $data)
             use (& $tokens, & $tag, $parseText) {
                 $a = $parseText(
                     '', $round, $total, $data
@@ -174,7 +174,7 @@ 
 
         $parse =
             function (
-                Callable $self, $round = 1, $total = 1
+                callable $self, $round = 1, $total = 1
             )
             use (
                 & $tokens, & $parent, & $tag, & $data,

htdocs/includes/restler/framework/Luracast/Restler/Filter/RateLimit.php

Indentation +144 added lines, -144 removed lines

@@ -19,160 +19,160 @@
  */
 class RateLimit implements iFilter, iUseAuthentication
 {
-    /**
-     * @var \Luracast\Restler\Restler;
-     */
-    public $restler;
-    /**
-     * @var int
-     */
-    public static $usagePerUnit = 1200;
-    /**
-     * @var int
-     */
-    public static $authenticatedUsagePerUnit = 5000;
-    /**
-     * @var string
-     */
-    public static $unit = 'hour';
-    /**
-     * @var string group the current api belongs to
-     */
-    public static $group = 'common';
+	/**
+	 * @var \Luracast\Restler\Restler;
+	 */
+	public $restler;
+	/**
+	 * @var int
+	 */
+	public static $usagePerUnit = 1200;
+	/**
+	 * @var int
+	 */
+	public static $authenticatedUsagePerUnit = 5000;
+	/**
+	 * @var string
+	 */
+	public static $unit = 'hour';
+	/**
+	 * @var string group the current api belongs to
+	 */
+	public static $group = 'common';
 
-    protected static $units = array(
-        'second' => 1,
-        'minute' => 60,
-        'hour' => 3600, // 60*60 seconds
-        'day' => 86400, // 60*60*24 seconds
-        'week' => 604800, // 60*60*24*7 seconds
-        'month' => 2592000, // 60*60*24*30 seconds
-    );
+	protected static $units = array(
+		'second' => 1,
+		'minute' => 60,
+		'hour' => 3600, // 60*60 seconds
+		'day' => 86400, // 60*60*24 seconds
+		'week' => 604800, // 60*60*24*7 seconds
+		'month' => 2592000, // 60*60*24*30 seconds
+	);
 
-    /**
-     * @var array all paths beginning with any of the following will be excluded
-     * from documentation
-     */
-    public static $excludedPaths = array('explorer');
+	/**
+	 * @var array all paths beginning with any of the following will be excluded
+	 * from documentation
+	 */
+	public static $excludedPaths = array('explorer');
 
 
-    /**
-     * @param string $unit
-     * @param int    $usagePerUnit
-     * @param int    $authenticatedUsagePerUnit set it to false to give unlimited access
-     *
-     * @throws \InvalidArgumentException
-     * @return void
-     */
-    public static function setLimit(
-        $unit, $usagePerUnit, $authenticatedUsagePerUnit = null
-    )
-    {
-        static::$unit = $unit;
-        static::$usagePerUnit = $usagePerUnit;
-        static::$authenticatedUsagePerUnit =
-            is_null($authenticatedUsagePerUnit) ? $usagePerUnit : $authenticatedUsagePerUnit;
-    }
+	/**
+	 * @param string $unit
+	 * @param int    $usagePerUnit
+	 * @param int    $authenticatedUsagePerUnit set it to false to give unlimited access
+	 *
+	 * @throws \InvalidArgumentException
+	 * @return void
+	 */
+	public static function setLimit(
+		$unit, $usagePerUnit, $authenticatedUsagePerUnit = null
+	)
+	{
+		static::$unit = $unit;
+		static::$usagePerUnit = $usagePerUnit;
+		static::$authenticatedUsagePerUnit =
+			is_null($authenticatedUsagePerUnit) ? $usagePerUnit : $authenticatedUsagePerUnit;
+	}
 
-    public function __isAllowed()
-    {
-        if (static::$authenticatedUsagePerUnit
-            == static::$usagePerUnit
-        ) return $this->check();
-        return null;
-    }
+	public function __isAllowed()
+	{
+		if (static::$authenticatedUsagePerUnit
+			== static::$usagePerUnit
+		) return $this->check();
+		return null;
+	}
 
-    public function __setAuthenticationStatus($isAuthenticated = false)
-    {
-        header('X-Auth-Status: ' . ($isAuthenticated ? 'true' : 'false'));
-        $this->check($isAuthenticated);
-    }
+	public function __setAuthenticationStatus($isAuthenticated = false)
+	{
+		header('X-Auth-Status: ' . ($isAuthenticated ? 'true' : 'false'));
+		$this->check($isAuthenticated);
+	}
 
-    private static function validate($unit)
-    {
-        if (!isset(static::$units[$unit]))
-            throw new \InvalidArgumentException(
-                'Rate Limit time unit should be '
-                . implode('|', array_keys(static::$units)) . '.'
-            );
-    }
+	private static function validate($unit)
+	{
+		if (!isset(static::$units[$unit]))
+			throw new \InvalidArgumentException(
+				'Rate Limit time unit should be '
+				. implode('|', array_keys(static::$units)) . '.'
+			);
+	}
 
-    private function check($isAuthenticated = false)
-    {
-        $path = $this->restler->url;
-        foreach (static::$excludedPaths as $exclude) {
-            if (empty($exclude) && empty($path)) {
-                return true;
-            } elseif (0 === strpos($path, $exclude)) {
-                return true;
-            }
-        }
-        static::validate(static::$unit);
-        $timeUnit = static::$units[static::$unit];
-        $maxPerUnit = $isAuthenticated
-            ? static::$authenticatedUsagePerUnit
-            : static::$usagePerUnit;
-        if ($maxPerUnit) {
-            $user = Defaults::$userIdentifierClass;
-            if (!method_exists($user, 'getUniqueIdentifier')) {
-                throw new \UnexpectedValueException('`Defaults::$userIdentifierClass` must implement `iIdentifyUser` interface');
-            }
-            $id = "RateLimit_" . $maxPerUnit . '_per_' . static::$unit
-                . '_for_' . static::$group
-                . '_' . $user::getUniqueIdentifier();
-            $lastRequest = $this->restler->cache->get($id, true)
-                ? : array('time' => 0, 'used' => 0);
-            $time = $lastRequest['time'];
-            $diff = time() - $time; # in seconds
-            $used = $lastRequest['used'];
+	private function check($isAuthenticated = false)
+	{
+		$path = $this->restler->url;
+		foreach (static::$excludedPaths as $exclude) {
+			if (empty($exclude) && empty($path)) {
+				return true;
+			} elseif (0 === strpos($path, $exclude)) {
+				return true;
+			}
+		}
+		static::validate(static::$unit);
+		$timeUnit = static::$units[static::$unit];
+		$maxPerUnit = $isAuthenticated
+			? static::$authenticatedUsagePerUnit
+			: static::$usagePerUnit;
+		if ($maxPerUnit) {
+			$user = Defaults::$userIdentifierClass;
+			if (!method_exists($user, 'getUniqueIdentifier')) {
+				throw new \UnexpectedValueException('`Defaults::$userIdentifierClass` must implement `iIdentifyUser` interface');
+			}
+			$id = "RateLimit_" . $maxPerUnit . '_per_' . static::$unit
+				. '_for_' . static::$group
+				. '_' . $user::getUniqueIdentifier();
+			$lastRequest = $this->restler->cache->get($id, true)
+				? : array('time' => 0, 'used' => 0);
+			$time = $lastRequest['time'];
+			$diff = time() - $time; # in seconds
+			$used = $lastRequest['used'];
 
-            header("X-RateLimit-Limit: $maxPerUnit per " . static::$unit);
-            if ($diff >= $timeUnit) {
-                $used = 1;
-                $time = time();
-            } elseif ($used >= $maxPerUnit) {
-                header("X-RateLimit-Remaining: 0");
-                $wait = $timeUnit - $diff;
-                sleep(1);
-                throw new RestException(429,
-                    'Rate limit of ' . $maxPerUnit . ' request' .
-                    ($maxPerUnit > 1 ? 's' : '') . ' per '
-                    . static::$unit . ' exceeded. Please wait for '
-                    . static::duration($wait) . '.'
-                );
-            } else {
-                $used++;
-            }
-            $remainingPerUnit = $maxPerUnit - $used;
-            header("X-RateLimit-Remaining: $remainingPerUnit");
-            $this->restler->cache->set($id,
-                array('time' => $time, 'used' => $used));
-        }
-        return true;
-    }
+			header("X-RateLimit-Limit: $maxPerUnit per " . static::$unit);
+			if ($diff >= $timeUnit) {
+				$used = 1;
+				$time = time();
+			} elseif ($used >= $maxPerUnit) {
+				header("X-RateLimit-Remaining: 0");
+				$wait = $timeUnit - $diff;
+				sleep(1);
+				throw new RestException(429,
+					'Rate limit of ' . $maxPerUnit . ' request' .
+					($maxPerUnit > 1 ? 's' : '') . ' per '
+					. static::$unit . ' exceeded. Please wait for '
+					. static::duration($wait) . '.'
+				);
+			} else {
+				$used++;
+			}
+			$remainingPerUnit = $maxPerUnit - $used;
+			header("X-RateLimit-Remaining: $remainingPerUnit");
+			$this->restler->cache->set($id,
+				array('time' => $time, 'used' => $used));
+		}
+		return true;
+	}
 
-    private function duration($secs)
-    {
-        $units = array(
-            'week' => (int)($secs / 86400 / 7),
-            'day' => $secs / 86400 % 7,
-            'hour' => $secs / 3600 % 24,
-            'minute' => $secs / 60 % 60,
-            'second' => $secs % 60);
+	private function duration($secs)
+	{
+		$units = array(
+			'week' => (int)($secs / 86400 / 7),
+			'day' => $secs / 86400 % 7,
+			'hour' => $secs / 3600 % 24,
+			'minute' => $secs / 60 % 60,
+			'second' => $secs % 60);
 
-        $ret = array();
+		$ret = array();
 
-        //$unit = 'days';
-        foreach ($units as $k => $v) {
-            if ($v > 0) {
-                $ret[] = $v > 1 ? "$v {$k}s" : "$v $k";
-                //$unit = $k;
-            }
-        }
-        $i = count($ret) - 1;
-        if ($i) {
-            $ret[$i] = 'and ' . $ret[$i];
-        }
-        return implode(' ', $ret); //." $unit.";
-    }
+		//$unit = 'days';
+		foreach ($units as $k => $v) {
+			if ($v > 0) {
+				$ret[] = $v > 1 ? "$v {$k}s" : "$v $k";
+				//$unit = $k;
+			}
+		}
+		$i = count($ret) - 1;
+		if ($i) {
+			$ret[$i] = 'and ' . $ret[$i];
+		}
+		return implode(' ', $ret); //." $unit.";
+	}
 }
\ No newline at end of file

Spacing +13 added lines, -13 removed lines

@@ -84,7 +84,7 @@ 
 
     public function __setAuthenticationStatus($isAuthenticated = false)
     {
-        header('X-Auth-Status: ' . ($isAuthenticated ? 'true' : 'false'));
+        header('X-Auth-Status: '.($isAuthenticated ? 'true' : 'false'));
         $this->check($isAuthenticated);
     }
 
@@ -93,7 +93,7 @@ 
         if (!isset(static::$units[$unit]))
             throw new \InvalidArgumentException(
                 'Rate Limit time unit should be '
-                . implode('|', array_keys(static::$units)) . '.'
+                . implode('|', array_keys(static::$units)).'.'
             );
     }
 
@@ -117,16 +117,16 @@ 
             if (!method_exists($user, 'getUniqueIdentifier')) {
                 throw new \UnexpectedValueException('`Defaults::$userIdentifierClass` must implement `iIdentifyUser` interface');
             }
-            $id = "RateLimit_" . $maxPerUnit . '_per_' . static::$unit
-                . '_for_' . static::$group
-                . '_' . $user::getUniqueIdentifier();
+            $id = "RateLimit_".$maxPerUnit.'_per_'.static::$unit
+                . '_for_'.static::$group
+                . '_'.$user::getUniqueIdentifier();
             $lastRequest = $this->restler->cache->get($id, true)
-                ? : array('time' => 0, 'used' => 0);
+                ?: array('time' => 0, 'used' => 0);
             $time = $lastRequest['time'];
             $diff = time() - $time; # in seconds
             $used = $lastRequest['used'];
 
-            header("X-RateLimit-Limit: $maxPerUnit per " . static::$unit);
+            header("X-RateLimit-Limit: $maxPerUnit per ".static::$unit);
             if ($diff >= $timeUnit) {
                 $used = 1;
                 $time = time();
@@ -135,10 +135,10 @@ 
                 $wait = $timeUnit - $diff;
                 sleep(1);
                 throw new RestException(429,
-                    'Rate limit of ' . $maxPerUnit . ' request' .
-                    ($maxPerUnit > 1 ? 's' : '') . ' per '
-                    . static::$unit . ' exceeded. Please wait for '
-                    . static::duration($wait) . '.'
+                    'Rate limit of '.$maxPerUnit.' request'.
+                    ($maxPerUnit > 1 ? 's' : '').' per '
+                    . static::$unit.' exceeded. Please wait for '
+                    . static::duration($wait).'.'
                 );
             } else {
                 $used++;
@@ -154,7 +154,7 @@ 
     private function duration($secs)
     {
         $units = array(
-            'week' => (int)($secs / 86400 / 7),
+            'week' => (int) ($secs / 86400 / 7),
             'day' => $secs / 86400 % 7,
             'hour' => $secs / 3600 % 24,
             'minute' => $secs / 60 % 60,
@@ -171,7 +171,7 @@ 
         }
         $i = count($ret) - 1;
         if ($i) {
-            $ret[$i] = 'and ' . $ret[$i];
+            $ret[$i] = 'and '.$ret[$i];
         }
         return implode(' ', $ret); //." $unit.";
     }

Braces +6 added lines, -3 removed lines

@@ -78,7 +78,9 @@ 
     {
         if (static::$authenticatedUsagePerUnit
             == static::$usagePerUnit
-        ) return $this->check();
+        ) {
+        	return $this->check();
+        }
         return null;
     }
 
@@ -90,11 +92,12 @@ 
 
     private static function validate($unit)
     {
-        if (!isset(static::$units[$unit]))
-            throw new \InvalidArgumentException(
+        if (!isset(static::$units[$unit])) {
+                    throw new \InvalidArgumentException(
                 'Rate Limit time unit should be '
                 . implode('|', array_keys(static::$units)) . '.'
             );
+        }
     }
 
     private function check($isAuthenticated = false)

htdocs/includes/restler/framework/Luracast/Restler/Format/AmfFormat.php

Indentation +17 added lines, -17 removed lines

@@ -21,28 +21,28 @@
  */
 class AmfFormat extends DependentFormat
 {
-    const MIME = 'application/x-amf';
-    const EXTENSION = 'amf';
+	const MIME = 'application/x-amf';
+	const EXTENSION = 'amf';
 
-    const PACKAGE_NAME = 'zendframework/zendamf:dev-master';
-    const EXTERNAL_CLASS = 'ZendAmf\\Parser\\Amf3\\Deserializer';
+	const PACKAGE_NAME = 'zendframework/zendamf:dev-master';
+	const EXTERNAL_CLASS = 'ZendAmf\\Parser\\Amf3\\Deserializer';
 
-    public function encode($data, $humanReadable = false)
-    {
+	public function encode($data, $humanReadable = false)
+	{
 
-        $stream = new OutputStream();
-        $serializer = new Serializer($stream);
-        $serializer->writeTypeMarker($data);
+		$stream = new OutputStream();
+		$serializer = new Serializer($stream);
+		$serializer->writeTypeMarker($data);
 
-        return $stream->getStream();
-    }
+		return $stream->getStream();
+	}
 
-    public function decode($data)
-    {
-        $stream = new InputStream(substr($data, 1));
-        $deserializer = new Deserializer($stream);
+	public function decode($data)
+	{
+		$stream = new InputStream(substr($data, 1));
+		$deserializer = new Deserializer($stream);
 
-        return $deserializer->readTypeMarker();
-    }
+		return $deserializer->readTypeMarker();
+	}
 }
 

htdocs/includes/restler/framework/Luracast/Restler/Format/Format.php

Indentation +109 added lines, -109 removed lines

@@ -14,127 +14,127 @@
  */
 abstract class Format implements iFormat
 {
-    /**
-     * override in the extending class
-     */
-    const MIME = 'text/plain';
-    /**
-     * override in the extending class
-     */
-    const EXTENSION = 'txt';
+	/**
+	 * override in the extending class
+	 */
+	const MIME = 'text/plain';
+	/**
+	 * override in the extending class
+	 */
+	const EXTENSION = 'txt';
 
-    /**
-     * @var string charset encoding defaults to UTF8
-     */
-    protected $charset='utf-8';
+	/**
+	 * @var string charset encoding defaults to UTF8
+	 */
+	protected $charset='utf-8';
 
-    /**
-     * Injected at runtime
-     *
-     * @var \Luracast\Restler\Restler
-     */
-    public $restler;
+	/**
+	 * Injected at runtime
+	 *
+	 * @var \Luracast\Restler\Restler
+	 */
+	public $restler;
 
-    /**
-     * Get MIME type => Extension mappings as an associative array
-     *
-     * @return array list of mime strings for the format
-     * @example array('application/json'=>'json');
-     */
-    public function getMIMEMap()
-    {
-        return array(
-            static::MIME =>  static::EXTENSION
-        );
-    }
+	/**
+	 * Get MIME type => Extension mappings as an associative array
+	 *
+	 * @return array list of mime strings for the format
+	 * @example array('application/json'=>'json');
+	 */
+	public function getMIMEMap()
+	{
+		return array(
+			static::MIME =>  static::EXTENSION
+		);
+	}
 
-    /**
-     * Set the selected MIME type
-     *
-     * @param string $mime
-     *            MIME type
-     */
-    public function setMIME($mime)
-    {
-        //do nothing
-    }
+	/**
+	 * Set the selected MIME type
+	 *
+	 * @param string $mime
+	 *            MIME type
+	 */
+	public function setMIME($mime)
+	{
+		//do nothing
+	}
 
-    /**
-     * Content-Type field of the HTTP header can send a charset
-     * parameter in the HTTP header to specify the character
-     * encoding of the document.
-     * This information is passed
-     * here so that Format class can encode data accordingly
-     * Format class may choose to ignore this and use its
-     * default character set.
-     *
-     * @param string $charset
-     *            Example utf-8
-     */
-    public function setCharset($charset)
-    {
-        $this->charset = $charset;
-    }
+	/**
+	 * Content-Type field of the HTTP header can send a charset
+	 * parameter in the HTTP header to specify the character
+	 * encoding of the document.
+	 * This information is passed
+	 * here so that Format class can encode data accordingly
+	 * Format class may choose to ignore this and use its
+	 * default character set.
+	 *
+	 * @param string $charset
+	 *            Example utf-8
+	 */
+	public function setCharset($charset)
+	{
+		$this->charset = $charset;
+	}
 
-    /**
-     * Content-Type accepted by the Format class
-     *
-     * @return string $charset Example utf-8
-     */
-    public function getCharset()
-    {
-        return $this->charset;
-    }
+	/**
+	 * Content-Type accepted by the Format class
+	 *
+	 * @return string $charset Example utf-8
+	 */
+	public function getCharset()
+	{
+		return $this->charset;
+	}
 
-    /**
-     * Get selected MIME type
-     */
-    public function getMIME()
-    {
-        return static::MIME;
-    }
+	/**
+	 * Get selected MIME type
+	 */
+	public function getMIME()
+	{
+		return static::MIME;
+	}
 
-    /**
-     * Set the selected file extension
-     *
-     * @param string $extension
-     *            file extension
-     */
-    public function setExtension($extension)
-    {
-        //do nothing;
-    }
+	/**
+	 * Set the selected file extension
+	 *
+	 * @param string $extension
+	 *            file extension
+	 */
+	public function setExtension($extension)
+	{
+		//do nothing;
+	}
 
-    /**
-     * Get the selected file extension
-     *
-     * @return string file extension
-     */
-    public function getExtension()
-    {
-        return static::EXTENSION;
-    }
+	/**
+	 * Get the selected file extension
+	 *
+	 * @return string file extension
+	 */
+	public function getExtension()
+	{
+		return static::EXTENSION;
+	}
 
-    /**
-     * @return boolean is parsing the request supported?
-     */
-    public function isReadable()
-    {
-        return true;
-    }
+	/**
+	 * @return boolean is parsing the request supported?
+	 */
+	public function isReadable()
+	{
+		return true;
+	}
 
-    /**
-     * @return boolean is composing response supported?
-     */
-    public function isWritable()
-    {
-        return true;
-    }
+	/**
+	 * @return boolean is composing response supported?
+	 */
+	public function isWritable()
+	{
+		return true;
+	}
 
-    public function __toString()
-    {
-        return $this->getExtension();
-    }
+	public function __toString()
+	{
+		return $this->getExtension();
+	}
 
 }
 

Spacing +1 added lines, -1 removed lines

@@ -26,7 +26,7 @@
     /**
      * @var string charset encoding defaults to UTF8
      */
-    protected $charset='utf-8';
+    protected $charset = 'utf-8';
 
     /**
      * Injected at runtime

htdocs/includes/restler/framework/Luracast/Restler/Format/CsvFormat.php

Indentation +158 added lines, -158 removed lines

@@ -20,162 +20,162 @@
 class CsvFormat extends Format implements iDecodeStream
 {
 
-    const MIME = 'text/csv';
-    const EXTENSION = 'csv';
-    public static $delimiter = ',';
-    public static $enclosure = '"';
-    public static $escape = '\\';
-    public static $haveHeaders = null;
-
-    /**
-     * Encode the given data in the csv format
-     *
-     * @param array   $data
-     *            resulting data that needs to
-     *            be encoded in the given format
-     * @param boolean $humanReadable
-     *            set to TRUE when restler
-     *            is not running in production mode. Formatter has to
-     *            make the encoded output more human readable
-     *
-     * @return string encoded string
-     *
-     * @throws RestException 500 on unsupported data
-     */
-    public function encode($data, $humanReadable = false)
-    {
-        $char = Obj::$separatorChar;
-        Obj::$separatorChar = false;
-        $data = Obj::toArray($data);
-        Obj::$separatorChar = $char;
-        if (is_array($data) && array_values($data) == $data) {
-            //if indexed array
-            $lines = array();
-            $row = array_shift($data);
-            if (array_values($row) != $row) {
-                $lines[] = static::putRow(array_keys($row));
-            }
-            $lines[] = static::putRow(array_values($row));
-            foreach ($data as $row) {
-                $lines[] = static::putRow(array_values($row));
-            }
-            return implode(PHP_EOL, $lines) . PHP_EOL;
-        }
-        throw new RestException(
-            500,
-            'Unsupported data for ' . strtoupper(static::EXTENSION) . ' format'
-        );
-    }
-
-    protected static function putRow($data)
-    {
-        $fp = fopen('php://temp', 'r+');
-        fputcsv($fp, $data, static::$delimiter, static::$enclosure);
-        rewind($fp);
-        $data = fread($fp, 1048576);
-        fclose($fp);
-        return rtrim($data, PHP_EOL);
-    }
-
-    /**
-     * Decode the given data from the csv format
-     *
-     * @param string $data
-     *            data sent from client to
-     *            the api in the given format.
-     *
-     * @return array associative array of the parsed data
-     */
-    public function decode($data)
-    {
-        $decoded = array();
-
-        if (empty($data)) {
-            return $decoded;
-        }
-
-        $lines = array_filter(explode(PHP_EOL, $data));
-
-        $keys = false;
-        $row = static::getRow(array_shift($lines));
-
-        if (is_null(static::$haveHeaders)) {
-            //try to guess with the given data
-            static::$haveHeaders = !count(array_filter($row, 'is_numeric'));
-        }
-
-        static::$haveHeaders ? $keys = $row : $decoded[] = $row;
-
-        while (($row = static::getRow(array_shift($lines), $keys)) !== FALSE)
-            $decoded [] = $row;
-
-        $char = Obj::$separatorChar;
-        Obj::$separatorChar = false;
-        $decoded = Obj::toArray($decoded);
-        Obj::$separatorChar = $char;
-        return $decoded;
-    }
-
-    protected static function getRow($data, $keys = false)
-    {
-        if (empty($data)) {
-            return false;
-        }
-        $line = str_getcsv(
-            $data,
-            static::$delimiter,
-            static::$enclosure,
-            static::$escape
-        );
-
-        $row = array();
-        foreach ($line as $key => $value) {
-            if (is_numeric($value))
-                $value = floatval($value);
-            if ($keys) {
-                if (isset($keys [$key]))
-                    $row [$keys [$key]] = $value;
-            } else {
-                $row [$key] = $value;
-            }
-        }
-        if ($keys) {
-            for ($i = count($row); $i < count($keys); $i++) {
-                $row[$keys[$i]] = null;
-            }
-        }
-        return $row;
-    }
-
-    /**
-     * Decode the given data stream
-     *
-     * @param string $stream A stream resource with data
-     *                       sent from client to the api
-     *                       in the given format.
-     *
-     * @return array associative array of the parsed data
-     */
-    public function decodeStream($stream)
-    {
-        $decoded = array();
-
-        $keys = false;
-        $row = static::getRow(stream_get_line($stream, 0, PHP_EOL));
-        if (is_null(static::$haveHeaders)) {
-            //try to guess with the given data
-            static::$haveHeaders = !count(array_filter($row, 'is_numeric'));
-        }
-
-        static::$haveHeaders ? $keys = $row : $decoded[] = $row;
-
-        while (($row = static::getRow(stream_get_line($stream, 0, PHP_EOL), $keys)) !== FALSE)
-            $decoded [] = $row;
-
-        $char = Obj::$separatorChar;
-        Obj::$separatorChar = false;
-        $decoded = Obj::toArray($decoded);
-        Obj::$separatorChar = $char;
-        return $decoded;
-    }
+	const MIME = 'text/csv';
+	const EXTENSION = 'csv';
+	public static $delimiter = ',';
+	public static $enclosure = '"';
+	public static $escape = '\\';
+	public static $haveHeaders = null;
+
+	/**
+	 * Encode the given data in the csv format
+	 *
+	 * @param array   $data
+	 *            resulting data that needs to
+	 *            be encoded in the given format
+	 * @param boolean $humanReadable
+	 *            set to TRUE when restler
+	 *            is not running in production mode. Formatter has to
+	 *            make the encoded output more human readable
+	 *
+	 * @return string encoded string
+	 *
+	 * @throws RestException 500 on unsupported data
+	 */
+	public function encode($data, $humanReadable = false)
+	{
+		$char = Obj::$separatorChar;
+		Obj::$separatorChar = false;
+		$data = Obj::toArray($data);
+		Obj::$separatorChar = $char;
+		if (is_array($data) && array_values($data) == $data) {
+			//if indexed array
+			$lines = array();
+			$row = array_shift($data);
+			if (array_values($row) != $row) {
+				$lines[] = static::putRow(array_keys($row));
+			}
+			$lines[] = static::putRow(array_values($row));
+			foreach ($data as $row) {
+				$lines[] = static::putRow(array_values($row));
+			}
+			return implode(PHP_EOL, $lines) . PHP_EOL;
+		}
+		throw new RestException(
+			500,
+			'Unsupported data for ' . strtoupper(static::EXTENSION) . ' format'
+		);
+	}
+
+	protected static function putRow($data)
+	{
+		$fp = fopen('php://temp', 'r+');
+		fputcsv($fp, $data, static::$delimiter, static::$enclosure);
+		rewind($fp);
+		$data = fread($fp, 1048576);
+		fclose($fp);
+		return rtrim($data, PHP_EOL);
+	}
+
+	/**
+	 * Decode the given data from the csv format
+	 *
+	 * @param string $data
+	 *            data sent from client to
+	 *            the api in the given format.
+	 *
+	 * @return array associative array of the parsed data
+	 */
+	public function decode($data)
+	{
+		$decoded = array();
+
+		if (empty($data)) {
+			return $decoded;
+		}
+
+		$lines = array_filter(explode(PHP_EOL, $data));
+
+		$keys = false;
+		$row = static::getRow(array_shift($lines));
+
+		if (is_null(static::$haveHeaders)) {
+			//try to guess with the given data
+			static::$haveHeaders = !count(array_filter($row, 'is_numeric'));
+		}
+
+		static::$haveHeaders ? $keys = $row : $decoded[] = $row;
+
+		while (($row = static::getRow(array_shift($lines), $keys)) !== FALSE)
+			$decoded [] = $row;
+
+		$char = Obj::$separatorChar;
+		Obj::$separatorChar = false;
+		$decoded = Obj::toArray($decoded);
+		Obj::$separatorChar = $char;
+		return $decoded;
+	}
+
+	protected static function getRow($data, $keys = false)
+	{
+		if (empty($data)) {
+			return false;
+		}
+		$line = str_getcsv(
+			$data,
+			static::$delimiter,
+			static::$enclosure,
+			static::$escape
+		);
+
+		$row = array();
+		foreach ($line as $key => $value) {
+			if (is_numeric($value))
+				$value = floatval($value);
+			if ($keys) {
+				if (isset($keys [$key]))
+					$row [$keys [$key]] = $value;
+			} else {
+				$row [$key] = $value;
+			}
+		}
+		if ($keys) {
+			for ($i = count($row); $i < count($keys); $i++) {
+				$row[$keys[$i]] = null;
+			}
+		}
+		return $row;
+	}
+
+	/**
+	 * Decode the given data stream
+	 *
+	 * @param string $stream A stream resource with data
+	 *                       sent from client to the api
+	 *                       in the given format.
+	 *
+	 * @return array associative array of the parsed data
+	 */
+	public function decodeStream($stream)
+	{
+		$decoded = array();
+
+		$keys = false;
+		$row = static::getRow(stream_get_line($stream, 0, PHP_EOL));
+		if (is_null(static::$haveHeaders)) {
+			//try to guess with the given data
+			static::$haveHeaders = !count(array_filter($row, 'is_numeric'));
+		}
+
+		static::$haveHeaders ? $keys = $row : $decoded[] = $row;
+
+		while (($row = static::getRow(stream_get_line($stream, 0, PHP_EOL), $keys)) !== FALSE)
+			$decoded [] = $row;
+
+		$char = Obj::$separatorChar;
+		Obj::$separatorChar = false;
+		$decoded = Obj::toArray($decoded);
+		Obj::$separatorChar = $char;
+		return $decoded;
+	}
 }
\ No newline at end of file

Spacing +2 added lines, -2 removed lines

@@ -59,11 +59,11 @@
             foreach ($data as $row) {
                 $lines[] = static::putRow(array_values($row));
             }
-            return implode(PHP_EOL, $lines) . PHP_EOL;
+            return implode(PHP_EOL, $lines).PHP_EOL;
         }
         throw new RestException(
             500,
-            'Unsupported data for ' . strtoupper(static::EXTENSION) . ' format'
+            'Unsupported data for '.strtoupper(static::EXTENSION).' format'
         );
     }
 

Braces +12 added lines, -8 removed lines

@@ -106,8 +106,9 @@ 
 
         static::$haveHeaders ? $keys = $row : $decoded[] = $row;
 
-        while (($row = static::getRow(array_shift($lines), $keys)) !== FALSE)
-            $decoded [] = $row;
+        while (($row = static::getRow(array_shift($lines), $keys)) !== FALSE) {
+                    $decoded [] = $row;
+        }
 
         $char = Obj::$separatorChar;
         Obj::$separatorChar = false;
@@ -130,11 +131,13 @@ 
 
         $row = array();
         foreach ($line as $key => $value) {
-            if (is_numeric($value))
-                $value = floatval($value);
+            if (is_numeric($value)) {
+                            $value = floatval($value);
+            }
             if ($keys) {
-                if (isset($keys [$key]))
-                    $row [$keys [$key]] = $value;
+                if (isset($keys [$key])) {
+                                    $row [$keys [$key]] = $value;
+                }
             } else {
                 $row [$key] = $value;
             }
@@ -169,8 +172,9 @@ 
 
         static::$haveHeaders ? $keys = $row : $decoded[] = $row;
 
-        while (($row = static::getRow(stream_get_line($stream, 0, PHP_EOL), $keys)) !== FALSE)
-            $decoded [] = $row;
+        while (($row = static::getRow(stream_get_line($stream, 0, PHP_EOL), $keys)) !== FALSE) {
+                    $decoded [] = $row;
+        }
 
         $char = Obj::$separatorChar;
         Obj::$separatorChar = false;

htdocs/includes/restler/framework/Luracast/Restler/Format/TsvFormat.php

Indentation +6 added lines, -6 removed lines

@@ -15,10 +15,10 @@
  */
 class TsvFormat extends CsvFormat
 {
-    const MIME = 'text/csv';
-    const EXTENSION = 'csv';
-    public static $delimiter = "\t";
-    public static $enclosure = '"';
-    public static $escape = '\\';
-    public static $haveHeaders = null;
+	const MIME = 'text/csv';
+	const EXTENSION = 'csv';
+	public static $delimiter = "\t";
+	public static $enclosure = '"';
+	public static $escape = '\\';
+	public static $haveHeaders = null;
 }
\ No newline at end of file

htdocs/includes/restler/framework/Luracast/Restler/Format/XmlFormat.php

Indentation +313 added lines, -313 removed lines

@@ -20,334 +20,334 @@
  */
 class XmlFormat extends Format
 {
-    const MIME = 'application/xml';
-    const EXTENSION = 'xml';
+	const MIME = 'application/xml';
+	const EXTENSION = 'xml';
 
-    // ==================================================================
-    //
-    // Properties related to reading/parsing/decoding xml
-    //
-    // ------------------------------------------------------------------
-    public static $importSettingsFromXml = false;
-    public static $parseAttributes = true;
-    public static $parseNamespaces = true;
-    public static $parseTextNodeAsProperty = true;
+	// ==================================================================
+	//
+	// Properties related to reading/parsing/decoding xml
+	//
+	// ------------------------------------------------------------------
+	public static $importSettingsFromXml = false;
+	public static $parseAttributes = true;
+	public static $parseNamespaces = true;
+	public static $parseTextNodeAsProperty = true;
 
-    // ==================================================================
-    //
-    // Properties related to writing/encoding xml
-    //
-    // ------------------------------------------------------------------
-    public static $useTextNodeProperty = true;
-    public static $useNamespaces = true;
-    public static $cdataNames = array();
+	// ==================================================================
+	//
+	// Properties related to writing/encoding xml
+	//
+	// ------------------------------------------------------------------
+	public static $useTextNodeProperty = true;
+	public static $useNamespaces = true;
+	public static $cdataNames = array();
 
-    // ==================================================================
-    //
-    // Common Properties
-    //
-    // ------------------------------------------------------------------
-    public static $attributeNames = array();
-    public static $textNodeName = 'text';
-    public static $namespaces = array();
-    public static $namespacedProperties = array();
-    /**
-     * Default name for the root node.
-     *
-     * @var string $rootNodeName
-     */
-    public static $rootName = 'response';
-    public static $defaultTagName = 'item';
+	// ==================================================================
+	//
+	// Common Properties
+	//
+	// ------------------------------------------------------------------
+	public static $attributeNames = array();
+	public static $textNodeName = 'text';
+	public static $namespaces = array();
+	public static $namespacedProperties = array();
+	/**
+	 * Default name for the root node.
+	 *
+	 * @var string $rootNodeName
+	 */
+	public static $rootName = 'response';
+	public static $defaultTagName = 'item';
 
-    /**
-     * When you decode an XML its structure is copied to the static vars
-     * we can use this function to echo them out and then copy paste inside
-     * our service methods
-     *
-     * @return string PHP source code to reproduce the configuration
-     */
-    public static function exportCurrentSettings()
-    {
-        $s = 'XmlFormat::$rootName = "' . (self::$rootName) . "\";\n";
-        $s .= 'XmlFormat::$attributeNames = ' .
-            (var_export(self::$attributeNames, true)) . ";\n";
-        $s .= 'XmlFormat::$defaultTagName = "' .
-            self::$defaultTagName . "\";\n";
-        $s .= 'XmlFormat::$parseAttributes = ' .
-            (self::$parseAttributes ? 'true' : 'false') . ";\n";
-        $s .= 'XmlFormat::$parseNamespaces = ' .
-            (self::$parseNamespaces ? 'true' : 'false') . ";\n";
-        if (self::$parseNamespaces) {
-            $s .= 'XmlFormat::$namespaces = ' .
-                (var_export(self::$namespaces, true)) . ";\n";
-            $s .= 'XmlFormat::$namespacedProperties = ' .
-                (var_export(self::$namespacedProperties, true)) . ";\n";
-        }
+	/**
+	 * When you decode an XML its structure is copied to the static vars
+	 * we can use this function to echo them out and then copy paste inside
+	 * our service methods
+	 *
+	 * @return string PHP source code to reproduce the configuration
+	 */
+	public static function exportCurrentSettings()
+	{
+		$s = 'XmlFormat::$rootName = "' . (self::$rootName) . "\";\n";
+		$s .= 'XmlFormat::$attributeNames = ' .
+			(var_export(self::$attributeNames, true)) . ";\n";
+		$s .= 'XmlFormat::$defaultTagName = "' .
+			self::$defaultTagName . "\";\n";
+		$s .= 'XmlFormat::$parseAttributes = ' .
+			(self::$parseAttributes ? 'true' : 'false') . ";\n";
+		$s .= 'XmlFormat::$parseNamespaces = ' .
+			(self::$parseNamespaces ? 'true' : 'false') . ";\n";
+		if (self::$parseNamespaces) {
+			$s .= 'XmlFormat::$namespaces = ' .
+				(var_export(self::$namespaces, true)) . ";\n";
+			$s .= 'XmlFormat::$namespacedProperties = ' .
+				(var_export(self::$namespacedProperties, true)) . ";\n";
+		}
 
-        return $s;
-    }
+		return $s;
+	}
 
-    public function encode($data, $humanReadable = false)
-    {
-        $data = Obj::toArray($data);
-        $xml = new XMLWriter();
-        $xml->openMemory();
-        $xml->startDocument('1.0', $this->charset);
-        if ($humanReadable) {
-            $xml->setIndent(true);
-            $xml->setIndentString('    ');
-        }
-        static::$useNamespaces && isset(static::$namespacedProperties[static::$rootName])
-            ?
-            $xml->startElementNs(
-                static::$namespacedProperties[static::$rootName],
-                static::$rootName,
-                static::$namespaces[static::$namespacedProperties[static::$rootName]]
-            )
-            :
-            $xml->startElement(static::$rootName);
-        if (static::$useNamespaces) {
-            foreach (static::$namespaces as $prefix => $ns) {
-                if (isset(static::$namespacedProperties[static::$rootName])
-                    && static::$namespacedProperties[static::$rootName] == $prefix
-                ) {
-                    continue;
-                }
-                $prefix = 'xmlns' . (empty($prefix) ? '' : ':' . $prefix);
-                $xml->writeAttribute($prefix, $ns);
-            }
-        }
-        $this->write($xml, $data, static::$rootName);
-        $xml->endElement();
+	public function encode($data, $humanReadable = false)
+	{
+		$data = Obj::toArray($data);
+		$xml = new XMLWriter();
+		$xml->openMemory();
+		$xml->startDocument('1.0', $this->charset);
+		if ($humanReadable) {
+			$xml->setIndent(true);
+			$xml->setIndentString('    ');
+		}
+		static::$useNamespaces && isset(static::$namespacedProperties[static::$rootName])
+			?
+			$xml->startElementNs(
+				static::$namespacedProperties[static::$rootName],
+				static::$rootName,
+				static::$namespaces[static::$namespacedProperties[static::$rootName]]
+			)
+			:
+			$xml->startElement(static::$rootName);
+		if (static::$useNamespaces) {
+			foreach (static::$namespaces as $prefix => $ns) {
+				if (isset(static::$namespacedProperties[static::$rootName])
+					&& static::$namespacedProperties[static::$rootName] == $prefix
+				) {
+					continue;
+				}
+				$prefix = 'xmlns' . (empty($prefix) ? '' : ':' . $prefix);
+				$xml->writeAttribute($prefix, $ns);
+			}
+		}
+		$this->write($xml, $data, static::$rootName);
+		$xml->endElement();
 
-        return $xml->outputMemory();
-    }
+		return $xml->outputMemory();
+	}
 
-    public function write(XMLWriter $xml, $data, $parent)
-    {
-        $text = array();
-        if (is_array($data)) {
-            if (static::$useTextNodeProperty && isset($data[static::$textNodeName])) {
-                $text [] = $data[static::$textNodeName];
-                unset($data[static::$textNodeName]);
-            }
-            $attributes = array_flip(static::$attributeNames);
-            //make sure we deal with attributes first
-            $temp = array();
-            foreach ($data as $key => $value) {
-                if (isset($attributes[$key])) {
-                    $temp[$key] = $data[$key];
-                    unset($data[$key]);
-                }
-            }
-            $data = array_merge($temp, $data);
-            foreach ($data as $key => $value) {
-                if (is_numeric($key)) {
-                    if (!is_array($value)) {
-                        $text [] = $value;
-                        continue;
-                    }
-                    $key = static::$defaultTagName;
-                }
-                $useNS = static::$useNamespaces
-                    && !empty(static::$namespacedProperties[$key])
-                    && false === strpos($key, ':');
-                if (is_array($value)) {
-                    $useNS
-                        ? $xml->startElementNs(
-                        static::$namespacedProperties[$key],
-                        $key,
-                        null
-                    )
-                        : $xml->startElement($key);
-                    $this->write($xml, $value, $key);
-                    $xml->endElement();
-                    continue;
-                } elseif (is_bool($value)) {
-                    $value = $value ? 'true' : 'false';
-                }
-                if (isset($attributes[$key])) {
-                    $xml->writeAttribute($useNS ? static::$namespacedProperties[$key] . ':' . $key : $key, $value);
-                } else {
-                    $useNS
-                        ?
-                        $xml->startElementNs(
-                            static::$namespacedProperties[$key],
-                            $key,
-                            null
-                        )
-                        : $xml->startElement($key);
-                    $this->write($xml, $value, $key);
-                    $xml->endElement();
-                }
-            }
-        } else {
-            $text [] = (string)$data;
-        }
-        if (!empty($text)) {
-            if (count($text) == 1) {
-                in_array($parent, static::$cdataNames)
-                    ? $xml->writeCdata(implode('', $text))
-                    : $xml->text(implode('', $text));
-            } else {
-                foreach ($text as $t) {
-                    $xml->writeElement(static::$textNodeName, $t);
-                }
-            }
-        }
-    }
+	public function write(XMLWriter $xml, $data, $parent)
+	{
+		$text = array();
+		if (is_array($data)) {
+			if (static::$useTextNodeProperty && isset($data[static::$textNodeName])) {
+				$text [] = $data[static::$textNodeName];
+				unset($data[static::$textNodeName]);
+			}
+			$attributes = array_flip(static::$attributeNames);
+			//make sure we deal with attributes first
+			$temp = array();
+			foreach ($data as $key => $value) {
+				if (isset($attributes[$key])) {
+					$temp[$key] = $data[$key];
+					unset($data[$key]);
+				}
+			}
+			$data = array_merge($temp, $data);
+			foreach ($data as $key => $value) {
+				if (is_numeric($key)) {
+					if (!is_array($value)) {
+						$text [] = $value;
+						continue;
+					}
+					$key = static::$defaultTagName;
+				}
+				$useNS = static::$useNamespaces
+					&& !empty(static::$namespacedProperties[$key])
+					&& false === strpos($key, ':');
+				if (is_array($value)) {
+					$useNS
+						? $xml->startElementNs(
+						static::$namespacedProperties[$key],
+						$key,
+						null
+					)
+						: $xml->startElement($key);
+					$this->write($xml, $value, $key);
+					$xml->endElement();
+					continue;
+				} elseif (is_bool($value)) {
+					$value = $value ? 'true' : 'false';
+				}
+				if (isset($attributes[$key])) {
+					$xml->writeAttribute($useNS ? static::$namespacedProperties[$key] . ':' . $key : $key, $value);
+				} else {
+					$useNS
+						?
+						$xml->startElementNs(
+							static::$namespacedProperties[$key],
+							$key,
+							null
+						)
+						: $xml->startElement($key);
+					$this->write($xml, $value, $key);
+					$xml->endElement();
+				}
+			}
+		} else {
+			$text [] = (string)$data;
+		}
+		if (!empty($text)) {
+			if (count($text) == 1) {
+				in_array($parent, static::$cdataNames)
+					? $xml->writeCdata(implode('', $text))
+					: $xml->text(implode('', $text));
+			} else {
+				foreach ($text as $t) {
+					$xml->writeElement(static::$textNodeName, $t);
+				}
+			}
+		}
+	}
 
-    public function decode($data)
-    {
-        try {
-            if ($data == '') {
-                return array();
-            }
-            libxml_use_internal_errors(true);
-            libxml_disable_entity_loader(true);
-            $xml = simplexml_load_string($data,
-                "SimpleXMLElement", LIBXML_NOBLANKS | LIBXML_NOCDATA | LIBXML_COMPACT);
-            if (false === $xml) {
-                $error = libxml_get_last_error();
-                throw new RestException(400, 'Malformed XML. '
-                    . trim($error->message, "\r\n") . ' at line ' . $error->line);
-            }
-            libxml_clear_errors();
-            if (static::$importSettingsFromXml) {
-                static::$attributeNames = array();
-                static::$namespacedProperties = array();
-                static::$namespaces = array();
-                static::$rootName = $xml->getName();
-                $namespaces = $xml->getNamespaces();
-                if (count($namespaces)) {
-                    $p = strpos($data, $xml->getName());
-                    if ($p && $data[$p - 1] == ':') {
-                        $s = strpos($data, '<') + 1;
-                        $prefix = substr($data, $s, $p - $s - 1);
-                        static::$namespacedProperties[static::$rootName] = $prefix;
-                    }
-                }
-            }
-            $data = $this->read($xml);
-            if (count($data) == 1 && isset($data[static::$textNodeName])) {
-                $data = $data[static::$textNodeName];
-            }
+	public function decode($data)
+	{
+		try {
+			if ($data == '') {
+				return array();
+			}
+			libxml_use_internal_errors(true);
+			libxml_disable_entity_loader(true);
+			$xml = simplexml_load_string($data,
+				"SimpleXMLElement", LIBXML_NOBLANKS | LIBXML_NOCDATA | LIBXML_COMPACT);
+			if (false === $xml) {
+				$error = libxml_get_last_error();
+				throw new RestException(400, 'Malformed XML. '
+					. trim($error->message, "\r\n") . ' at line ' . $error->line);
+			}
+			libxml_clear_errors();
+			if (static::$importSettingsFromXml) {
+				static::$attributeNames = array();
+				static::$namespacedProperties = array();
+				static::$namespaces = array();
+				static::$rootName = $xml->getName();
+				$namespaces = $xml->getNamespaces();
+				if (count($namespaces)) {
+					$p = strpos($data, $xml->getName());
+					if ($p && $data[$p - 1] == ':') {
+						$s = strpos($data, '<') + 1;
+						$prefix = substr($data, $s, $p - $s - 1);
+						static::$namespacedProperties[static::$rootName] = $prefix;
+					}
+				}
+			}
+			$data = $this->read($xml);
+			if (count($data) == 1 && isset($data[static::$textNodeName])) {
+				$data = $data[static::$textNodeName];
+			}
 
-            return $data;
-        } catch (\RuntimeException $e) {
-            throw new RestException(400,
-                "Error decoding request. " . $e->getMessage());
-        }
-    }
+			return $data;
+		} catch (\RuntimeException $e) {
+			throw new RestException(400,
+				"Error decoding request. " . $e->getMessage());
+		}
+	}
 
-    public function read(SimpleXMLElement $xml, $namespaces = null)
-    {
-        $r = array();
-        $text = (string)$xml;
+	public function read(SimpleXMLElement $xml, $namespaces = null)
+	{
+		$r = array();
+		$text = (string)$xml;
 
-        if (static::$parseAttributes) {
-            $attributes = $xml->attributes();
-            foreach ($attributes as $key => $value) {
-                if (static::$importSettingsFromXml
-                    && !in_array($key, static::$attributeNames)
-                ) {
-                    static::$attributeNames[] = $key;
-                }
-                $r[$key] = static::setType((string)$value);
-            }
-        }
-        $children = $xml->children();
-        foreach ($children as $key => $value) {
-            if ($key == static::$defaultTagName) {
-                $r[] = $this->read($value);
-            } elseif (isset($r[$key])) {
-                if (is_array($r[$key])) {
-                    if ($r[$key] != array_values($r[$key])) {
-                        $r[$key] = array($r[$key]);
-                    }
-                } else {
-                    $r[$key] = array($r[$key]);
-                }
-                $r[$key][] = $this->read($value, $namespaces);
-            } else {
-                $r[$key] = $this->read($value);
-            }
-        }
+		if (static::$parseAttributes) {
+			$attributes = $xml->attributes();
+			foreach ($attributes as $key => $value) {
+				if (static::$importSettingsFromXml
+					&& !in_array($key, static::$attributeNames)
+				) {
+					static::$attributeNames[] = $key;
+				}
+				$r[$key] = static::setType((string)$value);
+			}
+		}
+		$children = $xml->children();
+		foreach ($children as $key => $value) {
+			if ($key == static::$defaultTagName) {
+				$r[] = $this->read($value);
+			} elseif (isset($r[$key])) {
+				if (is_array($r[$key])) {
+					if ($r[$key] != array_values($r[$key])) {
+						$r[$key] = array($r[$key]);
+					}
+				} else {
+					$r[$key] = array($r[$key]);
+				}
+				$r[$key][] = $this->read($value, $namespaces);
+			} else {
+				$r[$key] = $this->read($value);
+			}
+		}
 
-        if (static::$parseNamespaces) {
-            if (is_null($namespaces)) {
-                $namespaces = $xml->getDocNamespaces(true);
-            }
-            foreach ($namespaces as $prefix => $ns) {
-                static::$namespaces[$prefix] = $ns;
-                if (static::$parseAttributes) {
-                    $attributes = $xml->attributes($ns);
-                    foreach ($attributes as $key => $value) {
-                        if (isset($r[$key])) {
-                            $key = "{$prefix}:$key";
-                        }
-                        if (static::$importSettingsFromXml
-                            && !in_array($key, static::$attributeNames)
-                        ) {
-                            static::$namespacedProperties[$key] = $prefix;
-                            static::$attributeNames[] = $key;
-                        }
-                        $r[$key] = static::setType((string)$value);
-                    }
-                }
-                $children = $xml->children($ns);
-                foreach ($children as $key => $value) {
-                    if (static::$importSettingsFromXml) {
-                        static::$namespacedProperties[$key] = $prefix;
-                    }
-                    if (isset($r[$key])) {
-                        if (is_array($r[$key])) {
-                            if ($r[$key] != array_values($r[$key])) {
-                                $r[$key] = array($r[$key]);
-                            }
-                        } else {
-                            $r[$key] = array($r[$key]);
-                        }
-                        $r[$key][] = $this->read($value, $namespaces);
-                    } else {
-                        $r[$key] = $this->read($value, $namespaces);
-                    }
-                }
-            }
-        }
+		if (static::$parseNamespaces) {
+			if (is_null($namespaces)) {
+				$namespaces = $xml->getDocNamespaces(true);
+			}
+			foreach ($namespaces as $prefix => $ns) {
+				static::$namespaces[$prefix] = $ns;
+				if (static::$parseAttributes) {
+					$attributes = $xml->attributes($ns);
+					foreach ($attributes as $key => $value) {
+						if (isset($r[$key])) {
+							$key = "{$prefix}:$key";
+						}
+						if (static::$importSettingsFromXml
+							&& !in_array($key, static::$attributeNames)
+						) {
+							static::$namespacedProperties[$key] = $prefix;
+							static::$attributeNames[] = $key;
+						}
+						$r[$key] = static::setType((string)$value);
+					}
+				}
+				$children = $xml->children($ns);
+				foreach ($children as $key => $value) {
+					if (static::$importSettingsFromXml) {
+						static::$namespacedProperties[$key] = $prefix;
+					}
+					if (isset($r[$key])) {
+						if (is_array($r[$key])) {
+							if ($r[$key] != array_values($r[$key])) {
+								$r[$key] = array($r[$key]);
+							}
+						} else {
+							$r[$key] = array($r[$key]);
+						}
+						$r[$key][] = $this->read($value, $namespaces);
+					} else {
+						$r[$key] = $this->read($value, $namespaces);
+					}
+				}
+			}
+		}
 
-        if (empty($text) && $text !== '0') {
-            if (empty($r)) {
-                return null;
-            }
-        } else {
-            empty($r)
-                ? $r = static::setType($text)
-                : (
-            static::$parseTextNodeAsProperty
-                ? $r[static::$textNodeName] = static::setType($text)
-                : $r[] = static::setType($text)
-            );
-        }
+		if (empty($text) && $text !== '0') {
+			if (empty($r)) {
+				return null;
+			}
+		} else {
+			empty($r)
+				? $r = static::setType($text)
+				: (
+			static::$parseTextNodeAsProperty
+				? $r[static::$textNodeName] = static::setType($text)
+				: $r[] = static::setType($text)
+			);
+		}
 
-        return $r;
-    }
+		return $r;
+	}
 
-    public static function setType($value)
-    {
-        if (empty($value) && $value !== '0') {
-            return null;
-        }
-        if ($value == 'true') {
-            return true;
-        }
-        if ($value == 'false') {
-            return true;
-        }
-        if (is_numeric($value)) {
-            return 0 + $value;
-        }
+	public static function setType($value)
+	{
+		if (empty($value) && $value !== '0') {
+			return null;
+		}
+		if ($value == 'true') {
+			return true;
+		}
+		if ($value == 'false') {
+			return true;
+		}
+		if (is_numeric($value)) {
+			return 0 + $value;
+		}
 
-        return $value;
-    }
+		return $value;
+	}
 }

Spacing +21 added lines, -21 removed lines

@@ -68,20 +68,20 @@ 
      */
     public static function exportCurrentSettings()
     {
-        $s = 'XmlFormat::$rootName = "' . (self::$rootName) . "\";\n";
-        $s .= 'XmlFormat::$attributeNames = ' .
-            (var_export(self::$attributeNames, true)) . ";\n";
-        $s .= 'XmlFormat::$defaultTagName = "' .
-            self::$defaultTagName . "\";\n";
-        $s .= 'XmlFormat::$parseAttributes = ' .
-            (self::$parseAttributes ? 'true' : 'false') . ";\n";
-        $s .= 'XmlFormat::$parseNamespaces = ' .
-            (self::$parseNamespaces ? 'true' : 'false') . ";\n";
+        $s = 'XmlFormat::$rootName = "'.(self::$rootName)."\";\n";
+        $s .= 'XmlFormat::$attributeNames = '.
+            (var_export(self::$attributeNames, true)).";\n";
+        $s .= 'XmlFormat::$defaultTagName = "'.
+            self::$defaultTagName."\";\n";
+        $s .= 'XmlFormat::$parseAttributes = '.
+            (self::$parseAttributes ? 'true' : 'false').";\n";
+        $s .= 'XmlFormat::$parseNamespaces = '.
+            (self::$parseNamespaces ? 'true' : 'false').";\n";
         if (self::$parseNamespaces) {
-            $s .= 'XmlFormat::$namespaces = ' .
-                (var_export(self::$namespaces, true)) . ";\n";
-            $s .= 'XmlFormat::$namespacedProperties = ' .
-                (var_export(self::$namespacedProperties, true)) . ";\n";
+            $s .= 'XmlFormat::$namespaces = '.
+                (var_export(self::$namespaces, true)).";\n";
+            $s .= 'XmlFormat::$namespacedProperties = '.
+                (var_export(self::$namespacedProperties, true)).";\n";
         }
 
         return $s;
@@ -113,7 +113,7 @@ 
                 ) {
                     continue;
                 }
-                $prefix = 'xmlns' . (empty($prefix) ? '' : ':' . $prefix);
+                $prefix = 'xmlns'.(empty($prefix) ? '' : ':'.$prefix);
                 $xml->writeAttribute($prefix, $ns);
             }
         }
@@ -167,7 +167,7 @@ 
                     $value = $value ? 'true' : 'false';
                 }
                 if (isset($attributes[$key])) {
-                    $xml->writeAttribute($useNS ? static::$namespacedProperties[$key] . ':' . $key : $key, $value);
+                    $xml->writeAttribute($useNS ? static::$namespacedProperties[$key].':'.$key : $key, $value);
                 } else {
                     $useNS
                         ?
@@ -182,7 +182,7 @@ 
                 }
             }
         } else {
-            $text [] = (string)$data;
+            $text [] = (string) $data;
         }
         if (!empty($text)) {
             if (count($text) == 1) {
@@ -210,7 +210,7 @@ 
             if (false === $xml) {
                 $error = libxml_get_last_error();
                 throw new RestException(400, 'Malformed XML. '
-                    . trim($error->message, "\r\n") . ' at line ' . $error->line);
+                    . trim($error->message, "\r\n").' at line '.$error->line);
             }
             libxml_clear_errors();
             if (static::$importSettingsFromXml) {
@@ -236,14 +236,14 @@ 
             return $data;
         } catch (\RuntimeException $e) {
             throw new RestException(400,
-                "Error decoding request. " . $e->getMessage());
+                "Error decoding request. ".$e->getMessage());
         }
     }
 
     public function read(SimpleXMLElement $xml, $namespaces = null)
     {
         $r = array();
-        $text = (string)$xml;
+        $text = (string) $xml;
 
         if (static::$parseAttributes) {
             $attributes = $xml->attributes();
@@ -253,7 +253,7 @@ 
                 ) {
                     static::$attributeNames[] = $key;
                 }
-                $r[$key] = static::setType((string)$value);
+                $r[$key] = static::setType((string) $value);
             }
         }
         $children = $xml->children();
@@ -292,7 +292,7 @@ 
                             static::$namespacedProperties[$key] = $prefix;
                             static::$attributeNames[] = $key;
                         }
-                        $r[$key] = static::setType((string)$value);
+                        $r[$key] = static::setType((string) $value);
                     }
                 }
                 $children = $xml->children($ns);