Dolibarr / dolibarr

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

Indentation +17 added lines, -17 removed lines

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

Braces +7 added lines, -3 removed lines

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

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

Indentation +14 added lines, -14 removed lines

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

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

Indentation +132 added lines, -132 removed lines

@@ -15,143 +15,143 @@
  */
 class Obj
 {
-    /**
-     * @var bool|string|callable
-     */
-    public static $stringEncoderFunction = false;
-    /**
-     * @var bool|string|callable
-     */
-    public static $numberEncoderFunction = false;
-    /**
-     * @var array key value pairs for fixing value types using functions.
-     * For example
-     *
-     *      'id'=>'intval'      will make sure all values of the id properties
-     *                          will be converted to integers intval function
-     *      'password'=> null   will remove all the password entries
-     */
-    public static $fix = array();
-    /**
-     * @var string character that is used to identify sub objects
-     *
-     * For example
-     *
-     * when Object::$separatorChar = '.';
-     *
-     * array('my.object'=>true) will result in
-     *
-     * array(
-     *    'my'=>array('object'=>true)
-     * );
-     */
-    public static $separatorChar = null;
-    /**
-     * @var bool set it to true when empty arrays, blank strings, null values
-     * to be automatically removed from response
-     */
-    public static $removeEmpty = false;
-    /**
-     * @var bool set it to true to remove all null values from the result
-     */
-    public static $removeNull = false;
+	/**
+	 * @var bool|string|callable
+	 */
+	public static $stringEncoderFunction = false;
+	/**
+	 * @var bool|string|callable
+	 */
+	public static $numberEncoderFunction = false;
+	/**
+	 * @var array key value pairs for fixing value types using functions.
+	 * For example
+	 *
+	 *      'id'=>'intval'      will make sure all values of the id properties
+	 *                          will be converted to integers intval function
+	 *      'password'=> null   will remove all the password entries
+	 */
+	public static $fix = array();
+	/**
+	 * @var string character that is used to identify sub objects
+	 *
+	 * For example
+	 *
+	 * when Object::$separatorChar = '.';
+	 *
+	 * array('my.object'=>true) will result in
+	 *
+	 * array(
+	 *    'my'=>array('object'=>true)
+	 * );
+	 */
+	public static $separatorChar = null;
+	/**
+	 * @var bool set it to true when empty arrays, blank strings, null values
+	 * to be automatically removed from response
+	 */
+	public static $removeEmpty = false;
+	/**
+	 * @var bool set it to true to remove all null values from the result
+	 */
+	public static $removeNull = false;
 
-    /**
-     * Convenience function that converts the given object
-     * in to associative array
-     *
-     * @static
-     *
-     * @param mixed $object                          that needs to be converted
-     *
-     * @param bool  $forceObjectTypeWhenEmpty        when set to true outputs
-     *                                               actual type  (array or
-     *                                               object) rather than
-     *                                               always an array when the
-     *                                               array/object is empty
-     *
-     * @return array
-     */
-    public static function toArray($object,
-                                   $forceObjectTypeWhenEmpty = false)
-    {
-        //if ($object instanceof JsonSerializable) { //wont work on PHP < 5.4
-        if (is_object($object)) {
-            if (method_exists($object, 'jsonSerialize')) {
-                $object = $object->jsonSerialize();
-            } elseif (method_exists($object, '__sleep')) {
-                $properties = $object->__sleep();
-                $array = array();
-                foreach ($properties as $key) {
-                    $value = self::toArray($object->{$key},
-                        $forceObjectTypeWhenEmpty);
-                    if (self::$stringEncoderFunction && is_string($value)) {
-                        $value = self::$stringEncoderFunction ($value);
-                    } elseif (self::$numberEncoderFunction && is_numeric($value)) {
-                        $value = self::$numberEncoderFunction ($value);
-                    }
-                    $array [$key] = $value;
-                }
-                return $array;
-            }
-        }
-        if (is_array($object) || is_object($object)) {
-            $count = 0;
-            $array = array();
-            foreach ($object as $key => $value) {
-                if (
-                    is_string(self::$separatorChar) &&
-                    false !== strpos($key, self::$separatorChar)
-                ) {
-                    list($key, $obj) = explode(self::$separatorChar, $key, 2);
-                    $object[$key][$obj] = $value;
-                    $value = $object[$key];
-                }
-                if (self::$removeEmpty && empty($value) && !is_numeric($value) && !is_bool($value)) {
-                    continue;
-                } elseif (self::$removeNull && is_null($value)) {
-                    continue;
-                }
-                if (array_key_exists($key, self::$fix)) {
-                    if (isset(self::$fix[$key])) {
-                        $value = call_user_func(self::$fix[$key], $value);
-                    } else {
-                        continue;
-                    }
-                }
-                $value = self::toArray($value, $forceObjectTypeWhenEmpty);
-                if (self::$stringEncoderFunction && is_string($value)) {
-                    $value = self::$encoderFunctionName ($value);
-                } elseif (self::$numberEncoderFunction && is_numeric($value)) {
-                    $value = self::$numberEncoderFunction ($value);
-                }
-                $array [$key] = $value;
-                $count++;
-            }
-            return $forceObjectTypeWhenEmpty && $count == 0 ? $object : $array;
-        }
+	/**
+	 * Convenience function that converts the given object
+	 * in to associative array
+	 *
+	 * @static
+	 *
+	 * @param mixed $object                          that needs to be converted
+	 *
+	 * @param bool  $forceObjectTypeWhenEmpty        when set to true outputs
+	 *                                               actual type  (array or
+	 *                                               object) rather than
+	 *                                               always an array when the
+	 *                                               array/object is empty
+	 *
+	 * @return array
+	 */
+	public static function toArray($object,
+								   $forceObjectTypeWhenEmpty = false)
+	{
+		//if ($object instanceof JsonSerializable) { //wont work on PHP < 5.4
+		if (is_object($object)) {
+			if (method_exists($object, 'jsonSerialize')) {
+				$object = $object->jsonSerialize();
+			} elseif (method_exists($object, '__sleep')) {
+				$properties = $object->__sleep();
+				$array = array();
+				foreach ($properties as $key) {
+					$value = self::toArray($object->{$key},
+						$forceObjectTypeWhenEmpty);
+					if (self::$stringEncoderFunction && is_string($value)) {
+						$value = self::$stringEncoderFunction ($value);
+					} elseif (self::$numberEncoderFunction && is_numeric($value)) {
+						$value = self::$numberEncoderFunction ($value);
+					}
+					$array [$key] = $value;
+				}
+				return $array;
+			}
+		}
+		if (is_array($object) || is_object($object)) {
+			$count = 0;
+			$array = array();
+			foreach ($object as $key => $value) {
+				if (
+					is_string(self::$separatorChar) &&
+					false !== strpos($key, self::$separatorChar)
+				) {
+					list($key, $obj) = explode(self::$separatorChar, $key, 2);
+					$object[$key][$obj] = $value;
+					$value = $object[$key];
+				}
+				if (self::$removeEmpty && empty($value) && !is_numeric($value) && !is_bool($value)) {
+					continue;
+				} elseif (self::$removeNull && is_null($value)) {
+					continue;
+				}
+				if (array_key_exists($key, self::$fix)) {
+					if (isset(self::$fix[$key])) {
+						$value = call_user_func(self::$fix[$key], $value);
+					} else {
+						continue;
+					}
+				}
+				$value = self::toArray($value, $forceObjectTypeWhenEmpty);
+				if (self::$stringEncoderFunction && is_string($value)) {
+					$value = self::$encoderFunctionName ($value);
+				} elseif (self::$numberEncoderFunction && is_numeric($value)) {
+					$value = self::$numberEncoderFunction ($value);
+				}
+				$array [$key] = $value;
+				$count++;
+			}
+			return $forceObjectTypeWhenEmpty && $count == 0 ? $object : $array;
+		}
 
-        return $object;
-    }
+		return $object;
+	}
 
-    public function __get($name)
-    {
-        isset(self::$fix[$name]) ? self::$fix[$name] : null;
-    }
+	public function __get($name)
+	{
+		isset(self::$fix[$name]) ? self::$fix[$name] : null;
+	}
 
-    public function __set($name, $function)
-    {
-        self::$fix[$name] = $function;
-    }
+	public function __set($name, $function)
+	{
+		self::$fix[$name] = $function;
+	}
 
-    public function __isset($name)
-    {
-        return isset(self::$fix[$name]);
-    }
+	public function __isset($name)
+	{
+		return isset(self::$fix[$name]);
+	}
 
-    public function __unset($name)
-    {
-        unset(self::$fix[$name]);
-    }
+	public function __unset($name)
+	{
+		unset(self::$fix[$name]);
+	}
 }
 

Spacing +4 added lines, -4 removed lines

@@ -86,9 +86,9 @@ 
                     $value = self::toArray($object->{$key},
                         $forceObjectTypeWhenEmpty);
                     if (self::$stringEncoderFunction && is_string($value)) {
-                        $value = self::$stringEncoderFunction ($value);
+                        $value = self::$stringEncoderFunction($value);
                     } elseif (self::$numberEncoderFunction && is_numeric($value)) {
-                        $value = self::$numberEncoderFunction ($value);
+                        $value = self::$numberEncoderFunction($value);
                     }
                     $array [$key] = $value;
                 }
@@ -121,9 +121,9 @@ 
                 }
                 $value = self::toArray($value, $forceObjectTypeWhenEmpty);
                 if (self::$stringEncoderFunction && is_string($value)) {
-                    $value = self::$encoderFunctionName ($value);
+                    $value = self::$encoderFunctionName($value);
                 } elseif (self::$numberEncoderFunction && is_numeric($value)) {
-                    $value = self::$numberEncoderFunction ($value);
+                    $value = self::$numberEncoderFunction($value);
                 }
                 $array [$key] = $value;
                 $count++;

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

Indentation +38 added lines, -38 removed lines

@@ -16,46 +16,46 @@
 class ValueObject implements iValueObject
 {
 
-    public function __toString()
-    {
-        return ' new ' . get_called_class() . '() ';
-    }
+	public function __toString()
+	{
+		return ' new ' . get_called_class() . '() ';
+	}
 
-    public static function __set_state(array $properties)
-    {
-        $class = get_called_class();
-        $instance = new $class ();
-        $vars = get_object_vars($instance);
-        foreach ($properties as $property => $value) {
-            if (property_exists($instance, $property)) {
-                // see if the property is accessible
-                if (array_key_exists($property, $vars)) {
-                    $instance->{$property} = $value;
-                } else {
-                    $method = 'set' . ucfirst($property);
-                    if (method_exists($instance, $method)) {
-                        call_user_func(array(
-                            $instance,
-                            $method
-                        ), $value);
-                    }
-                }
-            }
-        }
-        return $instance;
-    }
+	public static function __set_state(array $properties)
+	{
+		$class = get_called_class();
+		$instance = new $class ();
+		$vars = get_object_vars($instance);
+		foreach ($properties as $property => $value) {
+			if (property_exists($instance, $property)) {
+				// see if the property is accessible
+				if (array_key_exists($property, $vars)) {
+					$instance->{$property} = $value;
+				} else {
+					$method = 'set' . ucfirst($property);
+					if (method_exists($instance, $method)) {
+						call_user_func(array(
+							$instance,
+							$method
+						), $value);
+					}
+				}
+			}
+		}
+		return $instance;
+	}
 
-    public function __toArray()
-    {
-        $r = get_object_vars($this);
-        $methods = get_class_methods($this);
-        foreach ($methods as $m) {
-            if (substr($m, 0, 3) == 'get') {
-                $r [lcfirst(substr($m, 3))] = @$this->{$m} ();
-            }
-        }
-        return $r;
-    }
+	public function __toArray()
+	{
+		$r = get_object_vars($this);
+		$methods = get_class_methods($this);
+		foreach ($methods as $m) {
+			if (substr($m, 0, 3) == 'get') {
+				$r [lcfirst(substr($m, 3))] = @$this->{$m} ();
+			}
+		}
+		return $r;
+	}
 
 }
 

Spacing +3 added lines, -3 removed lines

@@ -18,13 +18,13 @@ 
 
     public function __toString()
     {
-        return ' new ' . get_called_class() . '() ';
+        return ' new '.get_called_class().'() ';
     }
 
     public static function __set_state(array $properties)
     {
         $class = get_called_class();
-        $instance = new $class ();
+        $instance = new $class();
         $vars = get_object_vars($instance);
         foreach ($properties as $property => $value) {
             if (property_exists($instance, $property)) {
@@ -32,7 +32,7 @@ 
                 if (array_key_exists($property, $vars)) {
                     $instance->{$property} = $value;
                 } else {
-                    $method = 'set' . ucfirst($property);
+                    $method = 'set'.ucfirst($property);
                     if (method_exists($instance, $method)) {
                         call_user_func(array(
                             $instance,

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

Indentation +18 added lines, -18 removed lines

@@ -16,24 +16,24 @@
 interface iValueObject
 {
 
-    /**
-     * This static method is called for creating an instance of the class by
-     * passing the initiation values as an array.
-     *
-     * @static
-     * @abstract
-     *
-     * @param array $properties
-     *
-     * @return iValueObject
-     */
-    public static function __set_state(array $properties);
+	/**
+	 * This static method is called for creating an instance of the class by
+	 * passing the initiation values as an array.
+	 *
+	 * @static
+	 * @abstract
+	 *
+	 * @param array $properties
+	 *
+	 * @return iValueObject
+	 */
+	public static function __set_state(array $properties);
 
-    /**
-     * This method provides a string representation for the instance
-     *
-     * @return string
-     */
-    public function __toString();
+	/**
+	 * This method provides a string representation for the instance
+	 *
+	 * @return string
+	 */
+	public function __toString();
 }
 

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

Indentation +37 added lines, -37 removed lines

@@ -15,41 +15,41 @@
  */
 class ApiMethodInfo extends ValueObject
 {
-    /**
-     * @var string target url
-     */
-    public $url;
-    /**
-     * @var string
-     */
-    public $className;
-    /**
-     * @var string
-     */
-    public $methodName;
-    /**
-     * @var array parameters to be passed to the api method
-     */
-    public $parameters = array();
-    /**
-     * @var array information on parameters in the form of array(name => index)
-     */
-    public $arguments = array();
-    /**
-     * @var array default values for parameters if any
-     * in the form of array(index => value)
-     */
-    public $defaults = array();
-    /**
-     * @var array key => value pair of method meta information
-     */
-    public $metadata = array();
-    /**
-     * @var int access level
-     * 0 - @public - available for all
-     * 1 - @hybrid - both public and protected (enhanced info for authorized)
-     * 2 - @protected comment - only for authenticated users
-     * 3 - protected method - only for authenticated users
-     */
-    public $accessLevel = 0;
+	/**
+	 * @var string target url
+	 */
+	public $url;
+	/**
+	 * @var string
+	 */
+	public $className;
+	/**
+	 * @var string
+	 */
+	public $methodName;
+	/**
+	 * @var array parameters to be passed to the api method
+	 */
+	public $parameters = array();
+	/**
+	 * @var array information on parameters in the form of array(name => index)
+	 */
+	public $arguments = array();
+	/**
+	 * @var array default values for parameters if any
+	 * in the form of array(index => value)
+	 */
+	public $defaults = array();
+	/**
+	 * @var array key => value pair of method meta information
+	 */
+	public $metadata = array();
+	/**
+	 * @var int access level
+	 * 0 - @public - available for all
+	 * 1 - @hybrid - both public and protected (enhanced info for authorized)
+	 * 2 - @protected comment - only for authenticated users
+	 * 3 - protected method - only for authenticated users
+	 */
+	public $accessLevel = 0;
 }
\ No newline at end of file

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

Indentation +675 added lines, -675 removed lines

@@ -22,706 +22,706 @@
  */
 class Validator implements iValidate
 {
-    public static $holdException = false;
-    public static $exceptions = array();
+	public static $holdException = false;
+	public static $exceptions = array();
 
-    public static $preFilters = array(
-        //'*'            => 'some_global_filter', //applied to all parameters
-        'string' => 'trim', //apply filter function by type (string)
-        //'string'       => 'strip_tags',
-        //'string'       => 'htmlspecialchars',
-        //'int'          => 'abs',
-        //'float'        => 'abs',
-        //'CustomClass'  => 'MyFilterClass::custom',
-        //                  please note that you wont get an instance
-        //                  of CustomClass. you will get an array instead
-    );
+	public static $preFilters = array(
+		//'*'            => 'some_global_filter', //applied to all parameters
+		'string' => 'trim', //apply filter function by type (string)
+		//'string'       => 'strip_tags',
+		//'string'       => 'htmlspecialchars',
+		//'int'          => 'abs',
+		//'float'        => 'abs',
+		//'CustomClass'  => 'MyFilterClass::custom',
+		//                  please note that you wont get an instance
+		//                  of CustomClass. you will get an array instead
+	);
 
-    /**
-     * Validate alphabetic characters.
-     *
-     * Check that given value contains only alphabetic characters.
-     *
-     * @param                $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     *
-     * @throws Invalid
-     */
-    public static function alpha($input, ValidationInfo $info = null)
-    {
-        if (ctype_alpha($input)) {
-            return $input;
-        }
-        if ($info && $info->fix) {
-            //remove non alpha characters
-            return preg_replace("/[^a-z]/i", "", $input);
-        }
-        throw new Invalid('Expecting only alphabetic characters.');
-    }
+	/**
+	 * Validate alphabetic characters.
+	 *
+	 * Check that given value contains only alphabetic characters.
+	 *
+	 * @param                $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 *
+	 * @throws Invalid
+	 */
+	public static function alpha($input, ValidationInfo $info = null)
+	{
+		if (ctype_alpha($input)) {
+			return $input;
+		}
+		if ($info && $info->fix) {
+			//remove non alpha characters
+			return preg_replace("/[^a-z]/i", "", $input);
+		}
+		throw new Invalid('Expecting only alphabetic characters.');
+	}
 
-    /**
-     * Validate UUID strings.
-     *
-     * Check that given value contains only alpha numeric characters and the length is 36 chars.
-     *
-     * @param                $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     *
-     * @throws Invalid
-     */
-    public static function uuid($input, ValidationInfo $info = null)
-    {
-        if (is_string($input) && preg_match(
-                '/^\{?[0-9a-f]{8}\-?[0-9a-f]{4}\-?[0-9a-f]{4}\-?[0-9a-f]{4}\-?[0-9a-f]{12}\}?$/i',
-                $input
-            )) {
-            return strtolower($input);
-        }
-        throw new Invalid('Expecting a Universally Unique IDentifier (UUID) string.');
-    }
+	/**
+	 * Validate UUID strings.
+	 *
+	 * Check that given value contains only alpha numeric characters and the length is 36 chars.
+	 *
+	 * @param                $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 *
+	 * @throws Invalid
+	 */
+	public static function uuid($input, ValidationInfo $info = null)
+	{
+		if (is_string($input) && preg_match(
+				'/^\{?[0-9a-f]{8}\-?[0-9a-f]{4}\-?[0-9a-f]{4}\-?[0-9a-f]{4}\-?[0-9a-f]{12}\}?$/i',
+				$input
+			)) {
+			return strtolower($input);
+		}
+		throw new Invalid('Expecting a Universally Unique IDentifier (UUID) string.');
+	}
 
-    /**
-     * Validate alpha numeric characters.
-     *
-     * Check that given value contains only alpha numeric characters.
-     *
-     * @param                $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     *
-     * @throws Invalid
-     */
-    public static function alphanumeric($input, ValidationInfo $info = null)
-    {
-        if (ctype_alnum($input)) {
-            return $input;
-        }
-        if ($info && $info->fix) {
-            //remove non alpha numeric and space characters
-            return preg_replace("/[^a-z0-9 ]/i", "", $input);
-        }
-        throw new Invalid('Expecting only alpha numeric characters.');
-    }
+	/**
+	 * Validate alpha numeric characters.
+	 *
+	 * Check that given value contains only alpha numeric characters.
+	 *
+	 * @param                $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 *
+	 * @throws Invalid
+	 */
+	public static function alphanumeric($input, ValidationInfo $info = null)
+	{
+		if (ctype_alnum($input)) {
+			return $input;
+		}
+		if ($info && $info->fix) {
+			//remove non alpha numeric and space characters
+			return preg_replace("/[^a-z0-9 ]/i", "", $input);
+		}
+		throw new Invalid('Expecting only alpha numeric characters.');
+	}
 
-    /**
-     * Validate printable characters.
-     *
-     * Check that given value contains only printable characters.
-     *
-     * @param                $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     *
-     * @throws Invalid
-     */
-    public static function printable($input, ValidationInfo $info = null)
-    {
-        if (ctype_print($input)) {
-            return $input;
-        }
-        if ($info && $info->fix) {
-            //remove non printable characters
-            return preg_replace('/[\x00-\x1F\x80-\xFF]/', '', $input);
-        }
-        throw new Invalid('Expecting only printable characters.');
-    }
+	/**
+	 * Validate printable characters.
+	 *
+	 * Check that given value contains only printable characters.
+	 *
+	 * @param                $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 *
+	 * @throws Invalid
+	 */
+	public static function printable($input, ValidationInfo $info = null)
+	{
+		if (ctype_print($input)) {
+			return $input;
+		}
+		if ($info && $info->fix) {
+			//remove non printable characters
+			return preg_replace('/[\x00-\x1F\x80-\xFF]/', '', $input);
+		}
+		throw new Invalid('Expecting only printable characters.');
+	}
 
-    /**
-     * Validate hexadecimal digits.
-     *
-     * Check that given value contains only hexadecimal digits.
-     *
-     * @param                $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     *
-     * @throws Invalid
-     */
-    public static function hex($input, ValidationInfo $info = null)
-    {
-        if (ctype_xdigit($input)) {
-            return $input;
-        }
-        throw new Invalid('Expecting only hexadecimal digits.');
-    }
+	/**
+	 * Validate hexadecimal digits.
+	 *
+	 * Check that given value contains only hexadecimal digits.
+	 *
+	 * @param                $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 *
+	 * @throws Invalid
+	 */
+	public static function hex($input, ValidationInfo $info = null)
+	{
+		if (ctype_xdigit($input)) {
+			return $input;
+		}
+		throw new Invalid('Expecting only hexadecimal digits.');
+	}
 
-    /**
-     * Color specified as hexadecimals
-     *
-     * Check that given value contains only color.
-     *
-     * @param                     $input
-     * @param ValidationInfo|null $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function color($input, ValidationInfo $info = null)
-    {
-        if (preg_match('/^#[a-f0-9]{6}$/i', $input)) {
-            return $input;
-        }
-        throw new Invalid('Expecting color as hexadecimal digits.');
-    }
+	/**
+	 * Color specified as hexadecimals
+	 *
+	 * Check that given value contains only color.
+	 *
+	 * @param                     $input
+	 * @param ValidationInfo|null $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function color($input, ValidationInfo $info = null)
+	{
+		if (preg_match('/^#[a-f0-9]{6}$/i', $input)) {
+			return $input;
+		}
+		throw new Invalid('Expecting color as hexadecimal digits.');
+	}
 
-    /**
-     * Validate Telephone number
-     *
-     * Check if the given value is numeric with or without a `+` prefix
-     *
-     * @param                $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     *
-     * @throws Invalid
-     */
-    public static function tel($input, ValidationInfo $info = null)
-    {
-        if (is_numeric($input) && '-' != substr($input, 0, 1)) {
-            return $input;
-        }
-        throw new Invalid('Expecting phone number, a numeric value ' .
-            'with optional `+` prefix');
-    }
+	/**
+	 * Validate Telephone number
+	 *
+	 * Check if the given value is numeric with or without a `+` prefix
+	 *
+	 * @param                $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 *
+	 * @throws Invalid
+	 */
+	public static function tel($input, ValidationInfo $info = null)
+	{
+		if (is_numeric($input) && '-' != substr($input, 0, 1)) {
+			return $input;
+		}
+		throw new Invalid('Expecting phone number, a numeric value ' .
+			'with optional `+` prefix');
+	}
 
-    /**
-     * Validate Email
-     *
-     * Check if the given string is a valid email
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function email($input, ValidationInfo $info = null)
-    {
-        $r = filter_var($input, FILTER_VALIDATE_EMAIL);
-        if ($r) {
-            return $r;
-        } elseif ($info && $info->fix) {
-            $r = filter_var($input, FILTER_SANITIZE_EMAIL);
-            return static::email($r);
-        }
-        throw new Invalid('Expecting email in `name@example.com` format');
-    }
+	/**
+	 * Validate Email
+	 *
+	 * Check if the given string is a valid email
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function email($input, ValidationInfo $info = null)
+	{
+		$r = filter_var($input, FILTER_VALIDATE_EMAIL);
+		if ($r) {
+			return $r;
+		} elseif ($info && $info->fix) {
+			$r = filter_var($input, FILTER_SANITIZE_EMAIL);
+			return static::email($r);
+		}
+		throw new Invalid('Expecting email in `name@example.com` format');
+	}
 
-    /**
-     * Validate IP Address
-     *
-     * Check if the given string is a valid ip address
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function ip($input, ValidationInfo $info = null)
-    {
-        $r = filter_var($input, FILTER_VALIDATE_IP);
-        if ($r) {
-            return $r;
-        }
+	/**
+	 * Validate IP Address
+	 *
+	 * Check if the given string is a valid ip address
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function ip($input, ValidationInfo $info = null)
+	{
+		$r = filter_var($input, FILTER_VALIDATE_IP);
+		if ($r) {
+			return $r;
+		}
 
-        throw new Invalid('Expecting IP address in IPV6 or IPV4 format');
-    }
+		throw new Invalid('Expecting IP address in IPV6 or IPV4 format');
+	}
 
-    /**
-     * Validate Url
-     *
-     * Check if the given string is a valid url
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function url($input, ValidationInfo $info = null)
-    {
-        $r = filter_var($input, FILTER_VALIDATE_URL);
-        if ($r) {
-            return $r;
-        } elseif ($info && $info->fix) {
-            $r = filter_var($input, FILTER_SANITIZE_URL);
-            return static::url($r);
-        }
-        throw new Invalid('Expecting url in `http://example.com` format');
-    }
+	/**
+	 * Validate Url
+	 *
+	 * Check if the given string is a valid url
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function url($input, ValidationInfo $info = null)
+	{
+		$r = filter_var($input, FILTER_VALIDATE_URL);
+		if ($r) {
+			return $r;
+		} elseif ($info && $info->fix) {
+			$r = filter_var($input, FILTER_SANITIZE_URL);
+			return static::url($r);
+		}
+		throw new Invalid('Expecting url in `http://example.com` format');
+	}
 
-    /**
-     * MySQL Date
-     *
-     * Check if the given string is a valid date in YYYY-MM-DD format
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function date($input, ValidationInfo $info = null)
-    {
-        if (
-            preg_match(
-                '#^(?P<year>\d{2}|\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})$#',
-                $input,
-                $date
-            )
-            && checkdate($date['month'], $date['day'], $date['year'])
-        ) {
-            return $input;
-        }
-        throw new Invalid(
-            'Expecting date in `YYYY-MM-DD` format, such as `'
-            . date("Y-m-d") . '`'
-        );
-    }
+	/**
+	 * MySQL Date
+	 *
+	 * Check if the given string is a valid date in YYYY-MM-DD format
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function date($input, ValidationInfo $info = null)
+	{
+		if (
+			preg_match(
+				'#^(?P<year>\d{2}|\d{4})-(?P<month>\d{1,2})-(?P<day>\d{1,2})$#',
+				$input,
+				$date
+			)
+			&& checkdate($date['month'], $date['day'], $date['year'])
+		) {
+			return $input;
+		}
+		throw new Invalid(
+			'Expecting date in `YYYY-MM-DD` format, such as `'
+			. date("Y-m-d") . '`'
+		);
+	}
 
-    /**
-     * MySQL DateTime
-     *
-     * Check if the given string is a valid date and time in YYY-MM-DD HH:MM:SS format
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function datetime($input, ValidationInfo $info = null)
-    {
-        if (
-            preg_match('/^(?P<year>19\d\d|20\d\d)\-(?P<month>0[1-9]|1[0-2])\-' .
-                '(?P<day>0\d|[1-2]\d|3[0-1]) (?P<h>0\d|1\d|2[0-3]' .
-                ')\:(?P<i>[0-5][0-9])\:(?P<s>[0-5][0-9])$/',
-                $input, $date)
-            && checkdate($date['month'], $date['day'], $date['year'])
-        ) {
-            return $input;
-        }
-        throw new Invalid(
-            'Expecting date and time in `YYYY-MM-DD HH:MM:SS` format, such as `'
-            . date("Y-m-d H:i:s") . '`'
-        );
-    }
+	/**
+	 * MySQL DateTime
+	 *
+	 * Check if the given string is a valid date and time in YYY-MM-DD HH:MM:SS format
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function datetime($input, ValidationInfo $info = null)
+	{
+		if (
+			preg_match('/^(?P<year>19\d\d|20\d\d)\-(?P<month>0[1-9]|1[0-2])\-' .
+				'(?P<day>0\d|[1-2]\d|3[0-1]) (?P<h>0\d|1\d|2[0-3]' .
+				')\:(?P<i>[0-5][0-9])\:(?P<s>[0-5][0-9])$/',
+				$input, $date)
+			&& checkdate($date['month'], $date['day'], $date['year'])
+		) {
+			return $input;
+		}
+		throw new Invalid(
+			'Expecting date and time in `YYYY-MM-DD HH:MM:SS` format, such as `'
+			. date("Y-m-d H:i:s") . '`'
+		);
+	}
 
-    /**
-     * Alias for Time
-     *
-     * Check if the given string is a valid time in HH:MM:SS format
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function time24($input, ValidationInfo $info = null)
-    {
-        return static::time($input, $info);
-    }
+	/**
+	 * Alias for Time
+	 *
+	 * Check if the given string is a valid time in HH:MM:SS format
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function time24($input, ValidationInfo $info = null)
+	{
+		return static::time($input, $info);
+	}
 
-    /**
-     * Time
-     *
-     * Check if the given string is a valid time in HH:MM:SS format
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function time($input, ValidationInfo $info = null)
-    {
-        if (preg_match('/^([01]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/', $input)) {
-            return $input;
-        }
-        throw new Invalid(
-            'Expecting time in `HH:MM:SS` format, such as `'
-            . date("H:i:s") . '`'
-        );
-    }
+	/**
+	 * Time
+	 *
+	 * Check if the given string is a valid time in HH:MM:SS format
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function time($input, ValidationInfo $info = null)
+	{
+		if (preg_match('/^([01]?[0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$/', $input)) {
+			return $input;
+		}
+		throw new Invalid(
+			'Expecting time in `HH:MM:SS` format, such as `'
+			. date("H:i:s") . '`'
+		);
+	}
 
-    /**
-     * Time in 12 hour format
-     *
-     * Check if the given string is a valid time 12 hour format
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return string
-     * @throws Invalid
-     */
-    public static function time12($input, ValidationInfo $info = null)
-    {
-        if (preg_match(
-            '/^([1-9]|1[0-2]|0[1-9]){1}(:[0-5][0-9])?\s?([aApP][mM]{1})?$/',
-            $input)
-        ) {
-            return $input;
-        }
-        throw new Invalid(
-            'Expecting time in 12 hour format, such as `08:00AM` and `10:05:11`'
-        );
-    }
+	/**
+	 * Time in 12 hour format
+	 *
+	 * Check if the given string is a valid time 12 hour format
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return string
+	 * @throws Invalid
+	 */
+	public static function time12($input, ValidationInfo $info = null)
+	{
+		if (preg_match(
+			'/^([1-9]|1[0-2]|0[1-9]){1}(:[0-5][0-9])?\s?([aApP][mM]{1})?$/',
+			$input)
+		) {
+			return $input;
+		}
+		throw new Invalid(
+			'Expecting time in 12 hour format, such as `08:00AM` and `10:05:11`'
+		);
+	}
 
-    /**
-     * Unix Timestamp
-     *
-     * Check if the given value is a valid timestamp
-     *
-     * @param String         $input
-     * @param ValidationInfo $info
-     *
-     * @return int
-     * @throws Invalid
-     */
-    public static function timestamp($input, ValidationInfo $info = null)
-    {
-        if ((string)(int)$input == $input
-            && ($input <= PHP_INT_MAX)
-            && ($input >= ~PHP_INT_MAX)
-        ) {
-            return (int)$input;
-        }
-        throw new Invalid('Expecting unix timestamp, such as ' . time());
-    }
+	/**
+	 * Unix Timestamp
+	 *
+	 * Check if the given value is a valid timestamp
+	 *
+	 * @param String         $input
+	 * @param ValidationInfo $info
+	 *
+	 * @return int
+	 * @throws Invalid
+	 */
+	public static function timestamp($input, ValidationInfo $info = null)
+	{
+		if ((string)(int)$input == $input
+			&& ($input <= PHP_INT_MAX)
+			&& ($input >= ~PHP_INT_MAX)
+		) {
+			return (int)$input;
+		}
+		throw new Invalid('Expecting unix timestamp, such as ' . time());
+	}
 
-    /**
-     * Validate the given input
-     *
-     * Validates the input and attempts to fix it when fix is requested
-     *
-     * @param mixed          $input
-     * @param ValidationInfo $info
-     * @param null           $full
-     *
-     * @throws \Exception
-     * @return array|bool|float|int|mixed|null|number|string
-     */
-    public static function validate($input, ValidationInfo $info, $full = null)
-    {
-        $html = Scope::get('Restler')->responseFormat instanceof HtmlFormat;
-        $name = $html ? "<strong>$info->label</strong>" : "`$info->name`";
-        if (
-            isset(static::$preFilters['*']) &&
-            is_scalar($input) &&
-            is_callable($func = static::$preFilters['*'])
-        ) {
-            $input = $func($input);
-        }
-        if (
-            isset(static::$preFilters[$info->type]) &&
-            (is_scalar($input) || !empty($info->children)) &&
-            is_callable($func = static::$preFilters[$info->type])
-        ) {
-            $input = $func($input);
-        }
-        try {
-            if (is_null($input)) {
-                if ($info->required) {
-                    throw new RestException (400,
-                        "$name is required.");
-                }
-                return null;
-            }
-            $error = isset ($info->message)
-                ? $info->message
-                : "Invalid value specified for $name";
+	/**
+	 * Validate the given input
+	 *
+	 * Validates the input and attempts to fix it when fix is requested
+	 *
+	 * @param mixed          $input
+	 * @param ValidationInfo $info
+	 * @param null           $full
+	 *
+	 * @throws \Exception
+	 * @return array|bool|float|int|mixed|null|number|string
+	 */
+	public static function validate($input, ValidationInfo $info, $full = null)
+	{
+		$html = Scope::get('Restler')->responseFormat instanceof HtmlFormat;
+		$name = $html ? "<strong>$info->label</strong>" : "`$info->name`";
+		if (
+			isset(static::$preFilters['*']) &&
+			is_scalar($input) &&
+			is_callable($func = static::$preFilters['*'])
+		) {
+			$input = $func($input);
+		}
+		if (
+			isset(static::$preFilters[$info->type]) &&
+			(is_scalar($input) || !empty($info->children)) &&
+			is_callable($func = static::$preFilters[$info->type])
+		) {
+			$input = $func($input);
+		}
+		try {
+			if (is_null($input)) {
+				if ($info->required) {
+					throw new RestException (400,
+						"$name is required.");
+				}
+				return null;
+			}
+			$error = isset ($info->message)
+				? $info->message
+				: "Invalid value specified for $name";
 
-            //if a validation method is specified
-            if (!empty($info->method)) {
-                $method = $info->method;
-                $info->method = '';
-                $r = self::validate($input, $info);
-                return $info->apiClassInstance->{$method} ($r);
-            }
+			//if a validation method is specified
+			if (!empty($info->method)) {
+				$method = $info->method;
+				$info->method = '';
+				$r = self::validate($input, $info);
+				return $info->apiClassInstance->{$method} ($r);
+			}
 
-            // when type is an array check if it passes for any type
-            if (is_array($info->type)) {
-                //trace("types are ".print_r($info->type, true));
-                $types = $info->type;
-                foreach ($types as $type) {
-                    $info->type = $type;
-                    try {
-                        $r = self::validate($input, $info);
-                        if ($r !== false) {
-                            return $r;
-                        }
-                    } catch (RestException $e) {
-                        // just continue
-                    }
-                }
-                throw new RestException (400, $error);
-            }
+			// when type is an array check if it passes for any type
+			if (is_array($info->type)) {
+				//trace("types are ".print_r($info->type, true));
+				$types = $info->type;
+				foreach ($types as $type) {
+					$info->type = $type;
+					try {
+						$r = self::validate($input, $info);
+						if ($r !== false) {
+							return $r;
+						}
+					} catch (RestException $e) {
+						// just continue
+					}
+				}
+				throw new RestException (400, $error);
+			}
 
-            //patterns are supported only for non numeric types
-            if (isset ($info->pattern)
-                && $info->type != 'int'
-                && $info->type != 'float'
-                && $info->type != 'number'
-            ) {
-                if (!preg_match($info->pattern, $input)) {
-                    throw new RestException (400, $error);
-                }
-            }
+			//patterns are supported only for non numeric types
+			if (isset ($info->pattern)
+				&& $info->type != 'int'
+				&& $info->type != 'float'
+				&& $info->type != 'number'
+			) {
+				if (!preg_match($info->pattern, $input)) {
+					throw new RestException (400, $error);
+				}
+			}
 
-            if (isset ($info->choice)) {
-                if (!$info->required && empty($input)) {
-                    //since its optional, and empty let it pass.
-                    $input = null;
-                } elseif (is_array($input)) {
-                    foreach ($input as $i) {
-                        if (!in_array($i, $info->choice)) {
-                            $error .= ". Expected one of (" . implode(',', $info->choice) . ").";
-                            throw new RestException (400, $error);
-                        }
-                    }
-                } elseif (!in_array($input, $info->choice)) {
-                    $error .= ". Expected one of (" . implode(',', $info->choice) . ").";
-                    throw new RestException (400, $error);
-                }
-            }
+			if (isset ($info->choice)) {
+				if (!$info->required && empty($input)) {
+					//since its optional, and empty let it pass.
+					$input = null;
+				} elseif (is_array($input)) {
+					foreach ($input as $i) {
+						if (!in_array($i, $info->choice)) {
+							$error .= ". Expected one of (" . implode(',', $info->choice) . ").";
+							throw new RestException (400, $error);
+						}
+					}
+				} elseif (!in_array($input, $info->choice)) {
+					$error .= ". Expected one of (" . implode(',', $info->choice) . ").";
+					throw new RestException (400, $error);
+				}
+			}
 
-            if (method_exists($class = get_called_class(), $info->type) && $info->type != 'validate') {
-                if (!$info->required && empty($input)) {
-                    //optional parameter with a empty value assume null
-                    return null;
-                }
-                try {
-                    return call_user_func("$class::$info->type", $input, $info);
-                } catch (Invalid $e) {
-                    throw new RestException(400, $error . '. ' . $e->getMessage());
-                }
-            }
+			if (method_exists($class = get_called_class(), $info->type) && $info->type != 'validate') {
+				if (!$info->required && empty($input)) {
+					//optional parameter with a empty value assume null
+					return null;
+				}
+				try {
+					return call_user_func("$class::$info->type", $input, $info);
+				} catch (Invalid $e) {
+					throw new RestException(400, $error . '. ' . $e->getMessage());
+				}
+			}
 
-            switch ($info->type) {
-                case 'int' :
-                case 'float' :
-                case 'number' :
-                    if (!is_numeric($input)) {
-                        $error .= '. Expecting '
-                            . ($info->type == 'int' ? 'integer' : 'numeric')
-                            . ' value';
-                        break;
-                    }
-                    if ($info->type == 'int' && (int)$input != $input) {
-                        if ($info->fix) {
-                            $r = (int)$input;
-                        } else {
-                            $error .= '. Expecting integer value';
-                            break;
-                        }
-                    } else {
-                        $r = $info->numericValue($input);
-                    }
-                    if (isset ($info->min) && $r < $info->min) {
-                        if ($info->fix) {
-                            $r = $info->min;
-                        } else {
-                            $error .= ". Minimum required value is $info->min.";
-                            break;
-                        }
-                    }
-                    if (isset ($info->max) && $r > $info->max) {
-                        if ($info->fix) {
-                            $r = $info->max;
-                        } else {
-                            $error .= ". Maximum allowed value is $info->max.";
-                            break;
-                        }
-                    }
-                    return $r;
+			switch ($info->type) {
+				case 'int' :
+				case 'float' :
+				case 'number' :
+					if (!is_numeric($input)) {
+						$error .= '. Expecting '
+							. ($info->type == 'int' ? 'integer' : 'numeric')
+							. ' value';
+						break;
+					}
+					if ($info->type == 'int' && (int)$input != $input) {
+						if ($info->fix) {
+							$r = (int)$input;
+						} else {
+							$error .= '. Expecting integer value';
+							break;
+						}
+					} else {
+						$r = $info->numericValue($input);
+					}
+					if (isset ($info->min) && $r < $info->min) {
+						if ($info->fix) {
+							$r = $info->min;
+						} else {
+							$error .= ". Minimum required value is $info->min.";
+							break;
+						}
+					}
+					if (isset ($info->max) && $r > $info->max) {
+						if ($info->fix) {
+							$r = $info->max;
+						} else {
+							$error .= ". Maximum allowed value is $info->max.";
+							break;
+						}
+					}
+					return $r;
 
-                case 'string' :
-                case 'password' : //password fields with string
-                case 'search' : //search field with string
-                    if (is_bool($input)) $input = $input ? 'true' : 'false';
-                    if (!is_string($input)) {
-                        $error .= '. Expecting alpha numeric value';
-                        break;
-                    }
-                    if ($info->required && $input === '') {
-                        $error = "$name is required.";
-                        break;
-                    }
-                    $r = strlen($input);
-                    if (isset ($info->min) && $r < $info->min) {
-                        if ($info->fix) {
-                            $input = str_pad($input, $info->min, $input);
-                        } else {
-                            $char = $info->min > 1 ? 'characters' : 'character';
-                            $error .= ". Minimum $info->min $char required.";
-                            break;
-                        }
-                    }
-                    if (isset ($info->max) && $r > $info->max) {
-                        if ($info->fix) {
-                            $input = substr($input, 0, $info->max);
-                        } else {
-                            $char = $info->max > 1 ? 'characters' : 'character';
-                            $error .= ". Maximum $info->max $char allowed.";
-                            break;
-                        }
-                    }
-                    return $input;
+				case 'string' :
+				case 'password' : //password fields with string
+				case 'search' : //search field with string
+					if (is_bool($input)) $input = $input ? 'true' : 'false';
+					if (!is_string($input)) {
+						$error .= '. Expecting alpha numeric value';
+						break;
+					}
+					if ($info->required && $input === '') {
+						$error = "$name is required.";
+						break;
+					}
+					$r = strlen($input);
+					if (isset ($info->min) && $r < $info->min) {
+						if ($info->fix) {
+							$input = str_pad($input, $info->min, $input);
+						} else {
+							$char = $info->min > 1 ? 'characters' : 'character';
+							$error .= ". Minimum $info->min $char required.";
+							break;
+						}
+					}
+					if (isset ($info->max) && $r > $info->max) {
+						if ($info->fix) {
+							$input = substr($input, 0, $info->max);
+						} else {
+							$char = $info->max > 1 ? 'characters' : 'character';
+							$error .= ". Maximum $info->max $char allowed.";
+							break;
+						}
+					}
+					return $input;
 
-                case 'bool':
-                case 'boolean':
-                    if (is_bool($input)) {
-                        return $input;
-                    }
-                    if (is_numeric($input)) {
-                        if ($input == 1) {
-                            return true;
-                        }
-                        if ($input == 0) {
-                            return false;
-                        }
-                    } elseif (is_string($input)) {
-                        switch (strtolower($input)) {
-                            case 'true':
-                                return true;
-                            case 'false':
-                                return false;
-                        }
-                    }
-                    if ($info->fix) {
-                        return $input ? true : false;
-                    }
-                    $error .= '. Expecting boolean value';
-                    break;
-                case 'array':
-                    if ($info->fix && is_string($input)) {
-                        $input = explode(CommentParser::$arrayDelimiter, $input);
-                    }
-                    if (is_array($input)) {
-                        $contentType =
-                            Util::nestedValue($info, 'contentType') ?: null;
-                        if ($info->fix) {
-                            if ($contentType == 'indexed') {
-                                $input = $info->filterArray($input, true);
-                            } elseif ($contentType == 'associative') {
-                                $input = $info->filterArray($input, false);
-                            }
-                        } elseif (
-                            $contentType == 'indexed' &&
-                            array_values($input) != $input
-                        ) {
-                            $error .= '. Expecting a list of items but an item is given';
-                            break;
-                        } elseif (
-                            $contentType == 'associative' &&
-                            array_values($input) == $input &&
-                            count($input)
-                        ) {
-                            $error .= '. Expecting an item but a list is given';
-                            break;
-                        }
-                        $r = count($input);
-                        if (isset ($info->min) && $r < $info->min) {
-                            $item = $info->max > 1 ? 'items' : 'item';
-                            $error .= ". Minimum $info->min $item required.";
-                            break;
-                        }
-                        if (isset ($info->max) && $r > $info->max) {
-                            if ($info->fix) {
-                                $input = array_slice($input, 0, $info->max);
-                            } else {
-                                $item = $info->max > 1 ? 'items' : 'item';
-                                $error .= ". Maximum $info->max $item allowed.";
-                                break;
-                            }
-                        }
-                        if (
-                            isset($contentType) &&
-                            $contentType != 'associative' &&
-                            $contentType != 'indexed'
-                        ) {
-                            $name = $info->name;
-                            $info->type = $contentType;
-                            unset($info->contentType);
-                            unset($info->min);
-                            unset($info->max);
-                            foreach ($input as $key => $chinput) {
-                                $info->name = "{$name}[$key]";
-                                $input[$key] = static::validate($chinput, $info);
-                            }
-                        }
-                        return $input;
-                    } elseif (isset($contentType)) {
-                        $error .= '. Expecting items of type ' .
-                            ($html ? "<strong>$contentType</strong>" : "`$contentType`");
-                        break;
-                    }
-                    break;
-                case 'mixed':
-                case 'unknown_type':
-                case 'unknown':
-                case null: //treat as unknown
-                    return $input;
-                default :
-                    if (!is_array($input)) {
-                        break;
-                    }
-                    //do type conversion
-                    if (class_exists($info->type)) {
-                        $input = $info->filterArray($input, false);
-                        $implements = class_implements($info->type);
-                        if (
-                            is_array($implements) &&
-                            in_array('Luracast\\Restler\\Data\\iValueObject', $implements)
-                        ) {
-                            return call_user_func(
-                                "{$info->type}::__set_state", $input
-                            );
-                        }
-                        $class = $info->type;
-                        $instance = new $class();
-                        if (is_array($info->children)) {
-                            if (
-                                empty($input) ||
-                                !is_array($input) ||
-                                $input === array_values($input)
-                            ) {
-                                $error .= '. Expecting an item of type ' .
-                                    ($html ? "<strong>$info->type</strong>" : "`$info->type`");
-                                break;
-                            }
-                            foreach ($info->children as $key => $value) {
-                                $cv = new ValidationInfo($value);
-                                $cv->name = "{$info->name}[$key]";
-                                if (array_key_exists($key, $input) || $cv->required) {
-                                    $instance->{$key} = static::validate(
-                                        Util::nestedValue($input, $key),
-                                        $cv
-                                    );
-                                }
-                            }
-                        }
-                        return $instance;
-                    }
-            }
-            throw new RestException (400, $error);
-        } catch (\Exception $e) {
-            static::$exceptions[$info->name] = $e;
-            if (static::$holdException) {
-                return null;
-            }
-            throw $e;
-        }
-    }
+				case 'bool':
+				case 'boolean':
+					if (is_bool($input)) {
+						return $input;
+					}
+					if (is_numeric($input)) {
+						if ($input == 1) {
+							return true;
+						}
+						if ($input == 0) {
+							return false;
+						}
+					} elseif (is_string($input)) {
+						switch (strtolower($input)) {
+							case 'true':
+								return true;
+							case 'false':
+								return false;
+						}
+					}
+					if ($info->fix) {
+						return $input ? true : false;
+					}
+					$error .= '. Expecting boolean value';
+					break;
+				case 'array':
+					if ($info->fix && is_string($input)) {
+						$input = explode(CommentParser::$arrayDelimiter, $input);
+					}
+					if (is_array($input)) {
+						$contentType =
+							Util::nestedValue($info, 'contentType') ?: null;
+						if ($info->fix) {
+							if ($contentType == 'indexed') {
+								$input = $info->filterArray($input, true);
+							} elseif ($contentType == 'associative') {
+								$input = $info->filterArray($input, false);
+							}
+						} elseif (
+							$contentType == 'indexed' &&
+							array_values($input) != $input
+						) {
+							$error .= '. Expecting a list of items but an item is given';
+							break;
+						} elseif (
+							$contentType == 'associative' &&
+							array_values($input) == $input &&
+							count($input)
+						) {
+							$error .= '. Expecting an item but a list is given';
+							break;
+						}
+						$r = count($input);
+						if (isset ($info->min) && $r < $info->min) {
+							$item = $info->max > 1 ? 'items' : 'item';
+							$error .= ". Minimum $info->min $item required.";
+							break;
+						}
+						if (isset ($info->max) && $r > $info->max) {
+							if ($info->fix) {
+								$input = array_slice($input, 0, $info->max);
+							} else {
+								$item = $info->max > 1 ? 'items' : 'item';
+								$error .= ". Maximum $info->max $item allowed.";
+								break;
+							}
+						}
+						if (
+							isset($contentType) &&
+							$contentType != 'associative' &&
+							$contentType != 'indexed'
+						) {
+							$name = $info->name;
+							$info->type = $contentType;
+							unset($info->contentType);
+							unset($info->min);
+							unset($info->max);
+							foreach ($input as $key => $chinput) {
+								$info->name = "{$name}[$key]";
+								$input[$key] = static::validate($chinput, $info);
+							}
+						}
+						return $input;
+					} elseif (isset($contentType)) {
+						$error .= '. Expecting items of type ' .
+							($html ? "<strong>$contentType</strong>" : "`$contentType`");
+						break;
+					}
+					break;
+				case 'mixed':
+				case 'unknown_type':
+				case 'unknown':
+				case null: //treat as unknown
+					return $input;
+				default :
+					if (!is_array($input)) {
+						break;
+					}
+					//do type conversion
+					if (class_exists($info->type)) {
+						$input = $info->filterArray($input, false);
+						$implements = class_implements($info->type);
+						if (
+							is_array($implements) &&
+							in_array('Luracast\\Restler\\Data\\iValueObject', $implements)
+						) {
+							return call_user_func(
+								"{$info->type}::__set_state", $input
+							);
+						}
+						$class = $info->type;
+						$instance = new $class();
+						if (is_array($info->children)) {
+							if (
+								empty($input) ||
+								!is_array($input) ||
+								$input === array_values($input)
+							) {
+								$error .= '. Expecting an item of type ' .
+									($html ? "<strong>$info->type</strong>" : "`$info->type`");
+								break;
+							}
+							foreach ($info->children as $key => $value) {
+								$cv = new ValidationInfo($value);
+								$cv->name = "{$info->name}[$key]";
+								if (array_key_exists($key, $input) || $cv->required) {
+									$instance->{$key} = static::validate(
+										Util::nestedValue($input, $key),
+										$cv
+									);
+								}
+							}
+						}
+						return $instance;
+					}
+			}
+			throw new RestException (400, $error);
+		} catch (\Exception $e) {
+			static::$exceptions[$info->name] = $e;
+			if (static::$holdException) {
+				return null;
+			}
+			throw $e;
+		}
+	}
 }

Spacing +22 added lines, -22 removed lines

@@ -188,7 +188,7 @@ 
         if (is_numeric($input) && '-' != substr($input, 0, 1)) {
             return $input;
         }
-        throw new Invalid('Expecting phone number, a numeric value ' .
+        throw new Invalid('Expecting phone number, a numeric value '.
             'with optional `+` prefix');
     }
 
@@ -284,7 +284,7 @@ 
         }
         throw new Invalid(
             'Expecting date in `YYYY-MM-DD` format, such as `'
-            . date("Y-m-d") . '`'
+            . date("Y-m-d").'`'
         );
     }
 
@@ -302,8 +302,8 @@ 
     public static function datetime($input, ValidationInfo $info = null)
     {
         if (
-            preg_match('/^(?P<year>19\d\d|20\d\d)\-(?P<month>0[1-9]|1[0-2])\-' .
-                '(?P<day>0\d|[1-2]\d|3[0-1]) (?P<h>0\d|1\d|2[0-3]' .
+            preg_match('/^(?P<year>19\d\d|20\d\d)\-(?P<month>0[1-9]|1[0-2])\-'.
+                '(?P<day>0\d|[1-2]\d|3[0-1]) (?P<h>0\d|1\d|2[0-3]'.
                 ')\:(?P<i>[0-5][0-9])\:(?P<s>[0-5][0-9])$/',
                 $input, $date)
             && checkdate($date['month'], $date['day'], $date['year'])
@@ -312,7 +312,7 @@ 
         }
         throw new Invalid(
             'Expecting date and time in `YYYY-MM-DD HH:MM:SS` format, such as `'
-            . date("Y-m-d H:i:s") . '`'
+            . date("Y-m-d H:i:s").'`'
         );
     }
 
@@ -350,7 +350,7 @@ 
         }
         throw new Invalid(
             'Expecting time in `HH:MM:SS` format, such as `'
-            . date("H:i:s") . '`'
+            . date("H:i:s").'`'
         );
     }
 
@@ -391,13 +391,13 @@ 
      */
     public static function timestamp($input, ValidationInfo $info = null)
     {
-        if ((string)(int)$input == $input
+        if ((string) (int) $input == $input
             && ($input <= PHP_INT_MAX)
             && ($input >= ~PHP_INT_MAX)
         ) {
-            return (int)$input;
+            return (int) $input;
         }
-        throw new Invalid('Expecting unix timestamp, such as ' . time());
+        throw new Invalid('Expecting unix timestamp, such as '.time());
     }
 
     /**
@@ -433,7 +433,7 @@ 
         try {
             if (is_null($input)) {
                 if ($info->required) {
-                    throw new RestException (400,
+                    throw new RestException(400,
                         "$name is required.");
                 }
                 return null;
@@ -465,7 +465,7 @@ 
                         // just continue
                     }
                 }
-                throw new RestException (400, $error);
+                throw new RestException(400, $error);
             }
 
             //patterns are supported only for non numeric types
@@ -475,7 +475,7 @@ 
                 && $info->type != 'number'
             ) {
                 if (!preg_match($info->pattern, $input)) {
-                    throw new RestException (400, $error);
+                    throw new RestException(400, $error);
                 }
             }
 
@@ -486,13 +486,13 @@ 
                 } elseif (is_array($input)) {
                     foreach ($input as $i) {
                         if (!in_array($i, $info->choice)) {
-                            $error .= ". Expected one of (" . implode(',', $info->choice) . ").";
-                            throw new RestException (400, $error);
+                            $error .= ". Expected one of (".implode(',', $info->choice).").";
+                            throw new RestException(400, $error);
                         }
                     }
                 } elseif (!in_array($input, $info->choice)) {
-                    $error .= ". Expected one of (" . implode(',', $info->choice) . ").";
-                    throw new RestException (400, $error);
+                    $error .= ". Expected one of (".implode(',', $info->choice).").";
+                    throw new RestException(400, $error);
                 }
             }
 
@@ -504,7 +504,7 @@ 
                 try {
                     return call_user_func("$class::$info->type", $input, $info);
                 } catch (Invalid $e) {
-                    throw new RestException(400, $error . '. ' . $e->getMessage());
+                    throw new RestException(400, $error.'. '.$e->getMessage());
                 }
             }
 
@@ -518,9 +518,9 @@ 
                             . ' value';
                         break;
                     }
-                    if ($info->type == 'int' && (int)$input != $input) {
+                    if ($info->type == 'int' && (int) $input != $input) {
                         if ($info->fix) {
-                            $r = (int)$input;
+                            $r = (int) $input;
                         } else {
                             $error .= '. Expecting integer value';
                             break;
@@ -663,7 +663,7 @@ 
                         }
                         return $input;
                     } elseif (isset($contentType)) {
-                        $error .= '. Expecting items of type ' .
+                        $error .= '. Expecting items of type '.
                             ($html ? "<strong>$contentType</strong>" : "`$contentType`");
                         break;
                     }
@@ -697,7 +697,7 @@ 
                                 !is_array($input) ||
                                 $input === array_values($input)
                             ) {
-                                $error .= '. Expecting an item of type ' .
+                                $error .= '. Expecting an item of type '.
                                     ($html ? "<strong>$info->type</strong>" : "`$info->type`");
                                 break;
                             }
@@ -715,7 +715,7 @@ 
                         return $instance;
                     }
             }
-            throw new RestException (400, $error);
+            throw new RestException(400, $error);
         } catch (\Exception $e) {
             static::$exceptions[$info->name] = $e;
             if (static::$holdException) {

Braces +3 added lines, -1 removed lines

@@ -549,7 +549,9 @@
                 case 'string' :
                 case 'password' : //password fields with string
                 case 'search' : //search field with string
-                    if (is_bool($input)) $input = $input ? 'true' : 'false';
+                    if (is_bool($input)) {
+                    	$input = $input ? 'true' : 'false';
+                    }
                     if (!is_string($input)) {
                         $error .= '. Expecting alpha numeric value';
                         break;

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

Indentation +227 added lines, -227 removed lines

@@ -19,255 +19,255 @@
  */
 class ValidationInfo implements iValueObject
 {
-    /**
-     * @var mixed given value for the parameter
-     */
-    public $value;
-    /**
-     * @var string proper name for given parameter
-     */
-    public $label;
-    /**
-     * @var string html element that can be used to represent the parameter for
-     *             input
-     */
-    public $field;
-    /**
-     * @var mixed default value for the parameter
-     */
-    public $default;
-    /**
-     * Name of the variable being validated
-     *
-     * @var string variable name
-     */
-    public $name;
+	/**
+	 * @var mixed given value for the parameter
+	 */
+	public $value;
+	/**
+	 * @var string proper name for given parameter
+	 */
+	public $label;
+	/**
+	 * @var string html element that can be used to represent the parameter for
+	 *             input
+	 */
+	public $field;
+	/**
+	 * @var mixed default value for the parameter
+	 */
+	public $default;
+	/**
+	 * Name of the variable being validated
+	 *
+	 * @var string variable name
+	 */
+	public $name;
 
-    /**
-     * @var bool is it required or not
-     */
-    public $required;
+	/**
+	 * @var bool is it required or not
+	 */
+	public $required;
 
-    /**
-     * @var string body or header or query where this parameter is coming from
-     * in the http request
-     */
-    public $from;
+	/**
+	 * @var string body or header or query where this parameter is coming from
+	 * in the http request
+	 */
+	public $from;
 
-    /**
-     * Data type of the variable being validated.
-     * It will be mostly string
-     *
-     * @var string|array multiple types are specified it will be of
-     *      type array otherwise it will be a string
-     */
-    public $type;
+	/**
+	 * Data type of the variable being validated.
+	 * It will be mostly string
+	 *
+	 * @var string|array multiple types are specified it will be of
+	 *      type array otherwise it will be a string
+	 */
+	public $type;
 
-    /**
-     * When the type is array, this field is used to define the type of the
-     * contents of the array
-     *
-     * @var string|null when all the items in an array are of certain type, we
-     * can set this property. It will be null if the items can be of any type
-     */
-    public $contentType;
+	/**
+	 * When the type is array, this field is used to define the type of the
+	 * contents of the array
+	 *
+	 * @var string|null when all the items in an array are of certain type, we
+	 * can set this property. It will be null if the items can be of any type
+	 */
+	public $contentType;
 
-    /**
-     * Should we attempt to fix the value?
-     * When set to false validation class should throw
-     * an exception or return false for the validate call.
-     * When set to true it will attempt to fix the value if possible
-     * or throw an exception or return false when it cant be fixed.
-     *
-     * @var boolean true or false
-     */
-    public $fix = false;
+	/**
+	 * Should we attempt to fix the value?
+	 * When set to false validation class should throw
+	 * an exception or return false for the validate call.
+	 * When set to true it will attempt to fix the value if possible
+	 * or throw an exception or return false when it cant be fixed.
+	 *
+	 * @var boolean true or false
+	 */
+	public $fix = false;
 
-    /**
-     * @var array of children to be validated
-     */
-    public $children = null;
+	/**
+	 * @var array of children to be validated
+	 */
+	public $children = null;
 
-    // ==================================================================
-    //
-    // VALUE RANGE
-    //
-    // ------------------------------------------------------------------
-    /**
-     * Given value should match one of the values in the array
-     *
-     * @var array of choices to match to
-     */
-    public $choice;
-    /**
-     * If the type is string it will set the lower limit for length
-     * else will specify the lower limit for the value
-     *
-     * @var number minimum value
-     */
-    public $min;
-    /**
-     * If the type is string it will set the upper limit limit for length
-     * else will specify the upper limit for the value
-     *
-     * @var number maximum value
-     */
-    public $max;
+	// ==================================================================
+	//
+	// VALUE RANGE
+	//
+	// ------------------------------------------------------------------
+	/**
+	 * Given value should match one of the values in the array
+	 *
+	 * @var array of choices to match to
+	 */
+	public $choice;
+	/**
+	 * If the type is string it will set the lower limit for length
+	 * else will specify the lower limit for the value
+	 *
+	 * @var number minimum value
+	 */
+	public $min;
+	/**
+	 * If the type is string it will set the upper limit limit for length
+	 * else will specify the upper limit for the value
+	 *
+	 * @var number maximum value
+	 */
+	public $max;
 
-    // ==================================================================
-    //
-    // REGEX VALIDATION
-    //
-    // ------------------------------------------------------------------
-    /**
-     * RegEx pattern to match the value
-     *
-     * @var string regular expression
-     */
-    public $pattern;
+	// ==================================================================
+	//
+	// REGEX VALIDATION
+	//
+	// ------------------------------------------------------------------
+	/**
+	 * RegEx pattern to match the value
+	 *
+	 * @var string regular expression
+	 */
+	public $pattern;
 
-    // ==================================================================
-    //
-    // CUSTOM VALIDATION
-    //
-    // ------------------------------------------------------------------
-    /**
-     * Rules specified for the parameter in the php doc comment.
-     * It is passed to the validation method as the second parameter
-     *
-     * @var array custom rule set
-     */
-    public $rules;
+	// ==================================================================
+	//
+	// CUSTOM VALIDATION
+	//
+	// ------------------------------------------------------------------
+	/**
+	 * Rules specified for the parameter in the php doc comment.
+	 * It is passed to the validation method as the second parameter
+	 *
+	 * @var array custom rule set
+	 */
+	public $rules;
 
-    /**
-     * Specifying a custom error message will override the standard error
-     * message return by the validator class
-     *
-     * @var string custom error response
-     */
-    public $message;
+	/**
+	 * Specifying a custom error message will override the standard error
+	 * message return by the validator class
+	 *
+	 * @var string custom error response
+	 */
+	public $message;
 
-    // ==================================================================
-    //
-    // METHODS
-    //
-    // ------------------------------------------------------------------
+	// ==================================================================
+	//
+	// METHODS
+	//
+	// ------------------------------------------------------------------
 
-    /**
-     * Name of the method to be used for validation.
-     * It will be receiving two parameters $input, $rules (array)
-     *
-     * @var string validation method name
-     */
-    public $method;
+	/**
+	 * Name of the method to be used for validation.
+	 * It will be receiving two parameters $input, $rules (array)
+	 *
+	 * @var string validation method name
+	 */
+	public $method;
 
-    /**
-     * Instance of the API class currently being called. It will be null most of
-     * the time. Only when method is defined it will contain an instance.
-     * This behavior is for lazy loading of the API class
-     *
-     * @var null|object will be null or api class instance
-     */
-    public $apiClassInstance = null;
+	/**
+	 * Instance of the API class currently being called. It will be null most of
+	 * the time. Only when method is defined it will contain an instance.
+	 * This behavior is for lazy loading of the API class
+	 *
+	 * @var null|object will be null or api class instance
+	 */
+	public $apiClassInstance = null;
 
-    public static function numericValue($value)
-    {
-        return ( int )$value == $value
-            ? ( int )$value
-            : floatval($value);
-    }
+	public static function numericValue($value)
+	{
+		return ( int )$value == $value
+			? ( int )$value
+			: floatval($value);
+	}
 
-    public static function arrayValue($value)
-    {
-        return is_array($value) ? $value : array(
-            $value
-        );
-    }
+	public static function arrayValue($value)
+	{
+		return is_array($value) ? $value : array(
+			$value
+		);
+	}
 
-    public static function stringValue($value, $glue = ',')
-    {
-        return is_array($value)
-            ? implode($glue, $value)
-            : ( string )$value;
-    }
+	public static function stringValue($value, $glue = ',')
+	{
+		return is_array($value)
+			? implode($glue, $value)
+			: ( string )$value;
+	}
 
-    public static function booleanValue($value)
-    {
-        return is_bool($value)
-            ? $value
-            : $value !== 'false';
-    }
+	public static function booleanValue($value)
+	{
+		return is_bool($value)
+			? $value
+			: $value !== 'false';
+	}
 
-    public static function filterArray(array $data, $keepNumericKeys)
-    {
-        $r = array();
-        foreach ($data as $key => $value) {
-            if (is_numeric($key)) {
-                if ($keepNumericKeys) {
-                    $r[$key] = $value;
-                }
-            } elseif (!$keepNumericKeys) {
-                $r[$key] = $value;
-            }
-        }
-        return $r;
-    }
+	public static function filterArray(array $data, $keepNumericKeys)
+	{
+		$r = array();
+		foreach ($data as $key => $value) {
+			if (is_numeric($key)) {
+				if ($keepNumericKeys) {
+					$r[$key] = $value;
+				}
+			} elseif (!$keepNumericKeys) {
+				$r[$key] = $value;
+			}
+		}
+		return $r;
+	}
 
-    public function __toString()
-    {
-        return ' new ValidationInfo() ';
-    }
+	public function __toString()
+	{
+		return ' new ValidationInfo() ';
+	}
 
-    private function getProperty(array &$from, $property)
-    {
-        $p = Util::nestedValue($from, $property);
-        unset($from[$property]);
-        $p2 = Util::nestedValue(
-            $from, CommentParser::$embeddedDataName, $property
-        );
-        unset($from[CommentParser::$embeddedDataName][$property]);
+	private function getProperty(array &$from, $property)
+	{
+		$p = Util::nestedValue($from, $property);
+		unset($from[$property]);
+		$p2 = Util::nestedValue(
+			$from, CommentParser::$embeddedDataName, $property
+		);
+		unset($from[CommentParser::$embeddedDataName][$property]);
 
-        if ($property == 'type' && $p == 'array' && $p2) {
-            $this->contentType = $p2;
-            return $p;
-        }
-        $r = is_null($p2) ? (is_null($p) ? null : $p) : $p2;
-        if (!is_null($r)) {
-            if ($property == 'min' || $property == 'max') {
-                return static::numericValue($r);
-            } elseif ($property == 'required' || $property == 'fix') {
-                return static::booleanValue($r);
-            } elseif ($property == 'choice') {
-                return static::arrayValue($r);
-            } elseif ($property == 'pattern') {
-                return static::stringValue($r);
-            }
-        }
-        return $r;
-    }
+		if ($property == 'type' && $p == 'array' && $p2) {
+			$this->contentType = $p2;
+			return $p;
+		}
+		$r = is_null($p2) ? (is_null($p) ? null : $p) : $p2;
+		if (!is_null($r)) {
+			if ($property == 'min' || $property == 'max') {
+				return static::numericValue($r);
+			} elseif ($property == 'required' || $property == 'fix') {
+				return static::booleanValue($r);
+			} elseif ($property == 'choice') {
+				return static::arrayValue($r);
+			} elseif ($property == 'pattern') {
+				return static::stringValue($r);
+			}
+		}
+		return $r;
+	}
 
-    public function __construct(array $info)
-    {
-        $properties = get_object_vars($this);
-        unset($properties['contentType']);
-        foreach ($properties as $property => $value) {
-            $this->{$property} = $this->getProperty($info, $property);
-        }
-        $inner = Util::nestedValue($info, 'properties');
-        $this->rules = !empty($inner) ? $inner + $info : $info;
-        unset($this->rules['properties']);
-        if (is_string($this->type) && $this->type == 'integer') {
-            $this->type = 'int';
-        }
-    }
+	public function __construct(array $info)
+	{
+		$properties = get_object_vars($this);
+		unset($properties['contentType']);
+		foreach ($properties as $property => $value) {
+			$this->{$property} = $this->getProperty($info, $property);
+		}
+		$inner = Util::nestedValue($info, 'properties');
+		$this->rules = !empty($inner) ? $inner + $info : $info;
+		unset($this->rules['properties']);
+		if (is_string($this->type) && $this->type == 'integer') {
+			$this->type = 'int';
+		}
+	}
 
-    /**
-     * Magic Method used for creating instance at run time
-     */
-    public static function __set_state(array $info)
-    {
-        $o = new self ($info);
-        return $o;
-    }
+	/**
+	 * Magic Method used for creating instance at run time
+	 */
+	public static function __set_state(array $info)
+	{
+		$o = new self ($info);
+		return $o;
+	}
 }
 

Spacing +4 added lines, -4 removed lines

@@ -172,8 +172,8 @@ 
 
     public static function numericValue($value)
     {
-        return ( int )$value == $value
-            ? ( int )$value
+        return (int) $value == $value
+            ? (int) $value
             : floatval($value);
     }
 
@@ -188,7 +188,7 @@ 
     {
         return is_array($value)
             ? implode($glue, $value)
-            : ( string )$value;
+            : (string) $value;
     }
 
     public static function booleanValue($value)
@@ -266,7 +266,7 @@ 
      */
     public static function __set_state(array $info)
     {
-        $o = new self ($info);
+        $o = new self($info);
         return $o;
     }
 }

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

Indentation +52 added lines, -52 removed lines

@@ -15,58 +15,58 @@
  */
 class Compose implements iCompose
 {
-    /**
-     * @var bool When restler is not running in production mode, this value will
-     * be checked to include the debug information on error response
-     */
-    public static $includeDebugInfo = true;
-    /**
-     * Current Restler instance
-     * Injected at runtime
-     *
-     * @var Restler
-     */
-    public $restler;
+	/**
+	 * @var bool When restler is not running in production mode, this value will
+	 * be checked to include the debug information on error response
+	 */
+	public static $includeDebugInfo = true;
+	/**
+	 * Current Restler instance
+	 * Injected at runtime
+	 *
+	 * @var Restler
+	 */
+	public $restler;
 
-    /**
-     * Result of an api call is passed to this method
-     * to create a standard structure for the data
-     *
-     * @param mixed $result can be a primitive or array or object
-     *
-     * @return mixed
-     */
-    public function response($result)
-    {
-        //TODO: check Defaults::language and change result accordingly
-        return $result;
-    }
+	/**
+	 * Result of an api call is passed to this method
+	 * to create a standard structure for the data
+	 *
+	 * @param mixed $result can be a primitive or array or object
+	 *
+	 * @return mixed
+	 */
+	public function response($result)
+	{
+		//TODO: check Defaults::language and change result accordingly
+		return $result;
+	}
 
-    /**
-     * When the api call results in RestException this method
-     * will be called to return the error message
-     *
-     * @param RestException $exception exception that has reasons for failure
-     *
-     * @return array
-     */
-    public function message(RestException $exception)
-    {
-        //TODO: check Defaults::language and change result accordingly
-        $r = array(
-            'error' => array(
-                    'code' => $exception->getCode(),
-                    'message' => $exception->getErrorMessage(),
-                ) + $exception->getDetails()
-        );
-        if (!Scope::get('Restler')->getProductionMode() && self::$includeDebugInfo) {
-            $r += array(
-                'debug' => array(
-                    'source' => $exception->getSource(),
-                    'stages' => $exception->getStages(),
-                )
-            );
-        }
-        return $r;
-    }
+	/**
+	 * When the api call results in RestException this method
+	 * will be called to return the error message
+	 *
+	 * @param RestException $exception exception that has reasons for failure
+	 *
+	 * @return array
+	 */
+	public function message(RestException $exception)
+	{
+		//TODO: check Defaults::language and change result accordingly
+		$r = array(
+			'error' => array(
+					'code' => $exception->getCode(),
+					'message' => $exception->getErrorMessage(),
+				) + $exception->getDetails()
+		);
+		if (!Scope::get('Restler')->getProductionMode() && self::$includeDebugInfo) {
+			$r += array(
+				'debug' => array(
+					'source' => $exception->getSource(),
+					'stages' => $exception->getStages(),
+				)
+			);
+		}
+		return $r;
+	}
 }
\ No newline at end of file