vanderlee / PHPSwaggerGen

SwaggerGen/Swagger/Type/AbstractType.php

Indentation +188 added lines, -188 removed lines

@@ -16,193 +16,193 @@
 abstract class AbstractType extends AbstractObject
 {
 
-    const REGEX_START = '/^';
-    const REGEX_FORMAT = '([a-z][a-z0-9]*)';
-    const REGEX_CONTENT = '(?:\((.*)\))?';
-    const REGEX_RANGE = '(?:([[<])(\\d*),(\\d*)([\\]>]))?';
-    const REGEX_DEFAULT = '(?:=(.+))?';
-    const REGEX_END = '$/i';
-
-    private static $classTypes = array(
-        'integer' => 'Integer',
-        'int' => 'Integer',
-        'int32' => 'Integer',
-        'int64' => 'Integer',
-        'long' => 'Integer',
-        'float' => 'Number',
-        'double' => 'Number',
-        'string' => 'String',
-        'uuid' => 'StringUuid',
-        'byte' => 'String',
-        'binary' => 'String',
-        'password' => 'String',
-        'enum' => 'String',
-        'boolean' => 'Boolean',
-        'bool' => 'Boolean',
-        'array' => 'Array',
-        'csv' => 'Array',
-        'ssv' => 'Array',
-        'tsv' => 'Array',
-        'pipes' => 'Array',
-        'date' => 'Date',
-        'datetime' => 'Date',
-        'date-time' => 'Date',
-        'object' => 'Object',
-        'refobject' => 'ReferenceObject',
-        'allof' => 'AllOf',
-    );
-
-    private $example = null;
-
-    /**
-     * Swap values of two variables.
-     * Used for sorting.
-     * @param mixed $a
-     * @param mixed $b
-     */
-    protected static function swap(&$a, &$b)
-    {
-        $tmp = $a;
-        $a = $b;
-        $b = $tmp;
-    }
-
-    /**
-     * @param string $list
-     * @return array
-     */
-    protected static function parseList($list)
-    {
-        $ret = array();
-        while ($item = self::parseListItem($list)) {
-            $ret[] = $item;
-        }
-        return $ret;
-    }
-
-    /**
-     * Extract an item from a comma-separated list of items.
-     *
-     * i.e. `a(x(x,x)),b(x)` returns `a(x(x,x))` and changes `$list` into `b(x)`.
-     * Note: brace nesting is not checked, e.g. `a{b(})` is a valid list item.
-     *
-     * @param string $list the list to parse
-     * @return string the extracted item
-     */
-    protected static function parseListItem(&$list)
-    {
-        $item = '';
-
-        $depth = 0;
-        $index = 0;
-        while ($index < strlen($list)) {
-            $c = $list[$index++];
-
-            if (strpos('{([<', $c) !== false) {
-                ++$depth;
-            } elseif (strpos('})]>', $c) !== false) {
-                --$depth;
-            } elseif ($c === ',' && $depth === 0) {
-                break;
-            }
-
-            $item .= $c;
-        }
-        $list = substr($list, $index);
-
-        return $item;
-    }
-
-    /**
-     * @param AbstractObject $parent
-     * @param $definition
-     * @constructor
-     */
-    public function __construct(AbstractObject $parent, $definition)
-    {
-        parent::__construct($parent);
-
-        $this->parseDefinition($definition);
-    }
-
-    abstract protected function parseDefinition($definition);
-
-    /**
-     * Overwrites default AbstractObject parser, since Types should not handle
-     * extensions themselves.
-     *
-     * @param string $command
-     * @param string $data
-     * @return AbstractType|boolean
-     * @throws Exception
-     */
-    public function handleCommand($command, $data = null)
-    {
-        if (strtolower($command) === 'example') {
-            if ($data === '') {
-                throw new Exception("Missing content for type example");
-            }
-            $json = preg_replace_callback('/([^{}:,]+)/', function ($match) {
-                json_decode($match[1]);
-                return json_last_error() === JSON_ERROR_NONE ? $match[1] : json_encode($match[1]);
-            }, trim($data));
-            $this->example = json_decode($json, true);
-
-            // In case input contains special chars, the above preg_replace would fail
-            //   Input could be a well-formed json already though
-            if ($this->example === null) {
-                $this->example = json_decode($data, true);
-            }
-            // If all fails, use input as-is
-            if ($this->example === null) {
-                $this->example = $data;
-            }
-
-            return $this;
-        }
-
-        return false;
-    }
-
-    public function toArray()
-    {
-        return self::arrayFilterNull(array_merge(array(
-            'example' => $this->example,
-        ), parent::toArray()));
-    }
-
-    /**
-     * @param AbstractObject $parent
-     * @param string $definition
-     * @param string $error
-     * @return self
-     * @throws Exception
-     */
-    public static function typeFactory($parent, $definition, $error = "Unparseable schema type definition: '%s'")
-    {
-        // Parse regex
-        $match = array();
-        if (preg_match('/^([a-z]+)/i', $definition, $match) === 1) {
-            $format = strtolower($match[1]);
-        } elseif (preg_match('/^(\[)(?:.*?)\]$/i', $definition, $match) === 1) {
-            $format = 'array';
-        } elseif (preg_match('/^(\{)(?:.*?)\}$/i', $definition, $match) === 1) {
-            $format = 'object';
-        } else {
-            throw new Exception(sprintf($error, $definition));
-        }
-
-        // Internal type if type known and not overwritten by definition
-        if ($parent->getTypeRegistry()->has($format)) {
-            $class = $parent->getTypeRegistry()->get($format);
-            return new $class($parent, $definition);
-        } elseif (isset(self::$classTypes[$format])) {
-            $type = self::$classTypes[$format];
-            $class = "\\SwaggerGen\\Swagger\\Type\\{$type}Type";
-            return new $class($parent, $definition);
-        } else {
-            return new ReferenceObjectType($parent, $definition);
-        }
-    }
+	const REGEX_START = '/^';
+	const REGEX_FORMAT = '([a-z][a-z0-9]*)';
+	const REGEX_CONTENT = '(?:\((.*)\))?';
+	const REGEX_RANGE = '(?:([[<])(\\d*),(\\d*)([\\]>]))?';
+	const REGEX_DEFAULT = '(?:=(.+))?';
+	const REGEX_END = '$/i';
+
+	private static $classTypes = array(
+		'integer' => 'Integer',
+		'int' => 'Integer',
+		'int32' => 'Integer',
+		'int64' => 'Integer',
+		'long' => 'Integer',
+		'float' => 'Number',
+		'double' => 'Number',
+		'string' => 'String',
+		'uuid' => 'StringUuid',
+		'byte' => 'String',
+		'binary' => 'String',
+		'password' => 'String',
+		'enum' => 'String',
+		'boolean' => 'Boolean',
+		'bool' => 'Boolean',
+		'array' => 'Array',
+		'csv' => 'Array',
+		'ssv' => 'Array',
+		'tsv' => 'Array',
+		'pipes' => 'Array',
+		'date' => 'Date',
+		'datetime' => 'Date',
+		'date-time' => 'Date',
+		'object' => 'Object',
+		'refobject' => 'ReferenceObject',
+		'allof' => 'AllOf',
+	);
+
+	private $example = null;
+
+	/**
+	 * Swap values of two variables.
+	 * Used for sorting.
+	 * @param mixed $a
+	 * @param mixed $b
+	 */
+	protected static function swap(&$a, &$b)
+	{
+		$tmp = $a;
+		$a = $b;
+		$b = $tmp;
+	}
+
+	/**
+	 * @param string $list
+	 * @return array
+	 */
+	protected static function parseList($list)
+	{
+		$ret = array();
+		while ($item = self::parseListItem($list)) {
+			$ret[] = $item;
+		}
+		return $ret;
+	}
+
+	/**
+	 * Extract an item from a comma-separated list of items.
+	 *
+	 * i.e. `a(x(x,x)),b(x)` returns `a(x(x,x))` and changes `$list` into `b(x)`.
+	 * Note: brace nesting is not checked, e.g. `a{b(})` is a valid list item.
+	 *
+	 * @param string $list the list to parse
+	 * @return string the extracted item
+	 */
+	protected static function parseListItem(&$list)
+	{
+		$item = '';
+
+		$depth = 0;
+		$index = 0;
+		while ($index < strlen($list)) {
+			$c = $list[$index++];
+
+			if (strpos('{([<', $c) !== false) {
+				++$depth;
+			} elseif (strpos('})]>', $c) !== false) {
+				--$depth;
+			} elseif ($c === ',' && $depth === 0) {
+				break;
+			}
+
+			$item .= $c;
+		}
+		$list = substr($list, $index);
+
+		return $item;
+	}
+
+	/**
+	 * @param AbstractObject $parent
+	 * @param $definition
+	 * @constructor
+	 */
+	public function __construct(AbstractObject $parent, $definition)
+	{
+		parent::__construct($parent);
+
+		$this->parseDefinition($definition);
+	}
+
+	abstract protected function parseDefinition($definition);
+
+	/**
+	 * Overwrites default AbstractObject parser, since Types should not handle
+	 * extensions themselves.
+	 *
+	 * @param string $command
+	 * @param string $data
+	 * @return AbstractType|boolean
+	 * @throws Exception
+	 */
+	public function handleCommand($command, $data = null)
+	{
+		if (strtolower($command) === 'example') {
+			if ($data === '') {
+				throw new Exception("Missing content for type example");
+			}
+			$json = preg_replace_callback('/([^{}:,]+)/', function ($match) {
+				json_decode($match[1]);
+				return json_last_error() === JSON_ERROR_NONE ? $match[1] : json_encode($match[1]);
+			}, trim($data));
+			$this->example = json_decode($json, true);
+
+			// In case input contains special chars, the above preg_replace would fail
+			//   Input could be a well-formed json already though
+			if ($this->example === null) {
+				$this->example = json_decode($data, true);
+			}
+			// If all fails, use input as-is
+			if ($this->example === null) {
+				$this->example = $data;
+			}
+
+			return $this;
+		}
+
+		return false;
+	}
+
+	public function toArray()
+	{
+		return self::arrayFilterNull(array_merge(array(
+			'example' => $this->example,
+		), parent::toArray()));
+	}
+
+	/**
+	 * @param AbstractObject $parent
+	 * @param string $definition
+	 * @param string $error
+	 * @return self
+	 * @throws Exception
+	 */
+	public static function typeFactory($parent, $definition, $error = "Unparseable schema type definition: '%s'")
+	{
+		// Parse regex
+		$match = array();
+		if (preg_match('/^([a-z]+)/i', $definition, $match) === 1) {
+			$format = strtolower($match[1]);
+		} elseif (preg_match('/^(\[)(?:.*?)\]$/i', $definition, $match) === 1) {
+			$format = 'array';
+		} elseif (preg_match('/^(\{)(?:.*?)\}$/i', $definition, $match) === 1) {
+			$format = 'object';
+		} else {
+			throw new Exception(sprintf($error, $definition));
+		}
+
+		// Internal type if type known and not overwritten by definition
+		if ($parent->getTypeRegistry()->has($format)) {
+			$class = $parent->getTypeRegistry()->get($format);
+			return new $class($parent, $definition);
+		} elseif (isset(self::$classTypes[$format])) {
+			$type = self::$classTypes[$format];
+			$class = "\\SwaggerGen\\Swagger\\Type\\{$type}Type";
+			return new $class($parent, $definition);
+		} else {
+			return new ReferenceObjectType($parent, $definition);
+		}
+	}
 
 }

Spacing +1 added lines, -1 removed lines

@@ -142,7 +142,7 @@
             if ($data === '') {
                 throw new Exception("Missing content for type example");
             }
-            $json = preg_replace_callback('/([^{}:,]+)/', function ($match) {
+            $json = preg_replace_callback('/([^{}:,]+)/', function($match) {
                 json_decode($match[1]);
                 return json_last_error() === JSON_ERROR_NONE ? $match[1] : json_encode($match[1]);
             }, trim($data));

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

@@ -198,7 +198,7 @@
             return new $class($parent, $definition);
         } elseif (isset(self::$classTypes[$format])) {
             $type = self::$classTypes[$format];
-            $class = "\\SwaggerGen\\Swagger\\Type\\{$type}Type";
+            $class = "\\SwaggerGen\\Swagger\\Type\\{$type}type";
             return new $class($parent, $definition);
         } else {
             return new ReferenceObjectType($parent, $definition);

SwaggerGen/Swagger/Type/Custom/MacType.php

Indentation +72 added lines, -72 removed lines

@@ -17,77 +17,77 @@
 class MacType extends StringType implements ICustomType
 {
 
-    const PATTERN = '^([0-9A-F]){2}(:[0-9A-F]{2}){5}$';
-
-    /**
-     * List of formats recognized by this class
-     * @var string[]
-     */
-    private static $formats = array('mac');
-
-    /**
-     * Construct and set up the regular expression for this type
-     *
-     * @param AbstractObject $parent
-     * @param string $definition
-     */
-    public function __construct(AbstractObject $parent, $definition)
-    {
-        $this->pattern = self::PATTERN;
-
-        parent::__construct($parent, $definition);
-    }
-
-    /**
-     * Parse a type definition string, assuming it belongs to this type
-     *
-     * @param string $definition
-     * @throws Exception
-     */
-    protected function parseDefinition($definition)
-    {
-        $definition = self::trim($definition);
-
-        $match = array();
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
-            throw new Exception("Unparseable MAC definition: '{$definition}'");
-        }
-
-        if (!in_array(strtolower($match[1]), self::$formats)) {
-            throw new Exception("Not a MAC: '{$definition}'");
-        }
-
-        $this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
-    }
-
-    /**
-     * Check (and optionally reformat) a default value
-     *
-     * @param string $value
-     * @return string
-     * @throws Exception
-     */
-    protected function validateDefault($value)
-    {
-        if (empty($value)) {
-            throw new Exception("Empty MAC default");
-        }
-
-        if (preg_match('/^([0-9A-F]){2}(:[0-9A-F]{2}){5}$/', $value) !== 1) {
-            throw new Exception("Invalid MAC default value: '{$value}'");
-        }
-
-        return $value;
-    }
-
-    public static function getFormats()
-    {
-        return self::$formats;
-    }
-
-    public static function setFormats(array $formats)
-    {
-        self::$formats = $formats;
-    }
+	const PATTERN = '^([0-9A-F]){2}(:[0-9A-F]{2}){5}$';
+
+	/**
+	 * List of formats recognized by this class
+	 * @var string[]
+	 */
+	private static $formats = array('mac');
+
+	/**
+	 * Construct and set up the regular expression for this type
+	 *
+	 * @param AbstractObject $parent
+	 * @param string $definition
+	 */
+	public function __construct(AbstractObject $parent, $definition)
+	{
+		$this->pattern = self::PATTERN;
+
+		parent::__construct($parent, $definition);
+	}
+
+	/**
+	 * Parse a type definition string, assuming it belongs to this type
+	 *
+	 * @param string $definition
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition)
+	{
+		$definition = self::trim($definition);
+
+		$match = array();
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
+			throw new Exception("Unparseable MAC definition: '{$definition}'");
+		}
+
+		if (!in_array(strtolower($match[1]), self::$formats)) {
+			throw new Exception("Not a MAC: '{$definition}'");
+		}
+
+		$this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
+	}
+
+	/**
+	 * Check (and optionally reformat) a default value
+	 *
+	 * @param string $value
+	 * @return string
+	 * @throws Exception
+	 */
+	protected function validateDefault($value)
+	{
+		if (empty($value)) {
+			throw new Exception("Empty MAC default");
+		}
+
+		if (preg_match('/^([0-9A-F]){2}(:[0-9A-F]{2}){5}$/', $value) !== 1) {
+			throw new Exception("Invalid MAC default value: '{$value}'");
+		}
+
+		return $value;
+	}
+
+	public static function getFormats()
+	{
+		return self::$formats;
+	}
+
+	public static function setFormats(array $formats)
+	{
+		self::$formats = $formats;
+	}
 
 }

SwaggerGen/Swagger/Type/Custom/ICustomType.php

Indentation +10 added lines, -10 removed lines

@@ -13,16 +13,16 @@
 interface ICustomType
 {
 
-    /**
-     * Return a list of formats recognized by this type
-     * @return string[]
-     */
-    public static function getFormats();
+	/**
+	 * Return a list of formats recognized by this type
+	 * @return string[]
+	 */
+	public static function getFormats();
 
-    /**
-     * Overwrite format names recognized by this type
-     * @param string[] $formats
-     */
-    public static function setFormats(array $formats);
+	/**
+	 * Overwrite format names recognized by this type
+	 * @param string[] $formats
+	 */
+	public static function setFormats(array $formats);
 
 }

SwaggerGen/Swagger/Type/Custom/EmailType.php

Indentation +72 added lines, -72 removed lines

@@ -17,77 +17,77 @@
 class EmailType extends StringType implements ICustomType
 {
 
-    const PATTERN = '\A[a-z0-9!#$%&\'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&\'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z';
-
-    /**
-     * List of formats recognized by this class
-     * @var string[]
-     */
-    private static $formats = array('email');
-
-    /**
-     * Construct and set up the regular expression for this type
-     *
-     * @param AbstractObject $parent
-     * @param string $definition
-     */
-    public function __construct(AbstractObject $parent, $definition)
-    {
-        $this->pattern = self::PATTERN;
-
-        parent::__construct($parent, $definition);
-    }
-
-    /**
-     * Parse a type definition string, assuming it belongs to this type
-     *
-     * @param string $definition
-     * @throws Exception
-     */
-    protected function parseDefinition($definition)
-    {
-        $definition = self::trim($definition);
-
-        $match = array();
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
-            throw new Exception("Unparseable email definition: '{$definition}'");
-        }
-
-        if (!in_array(strtolower($match[1]), self::$formats)) {
-            throw new Exception("Not an email: '{$definition}'");
-        }
-
-        $this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
-    }
-
-    /**
-     * Check (and optionally reformat) a default value
-     *
-     * @param string $value
-     * @return string
-     * @throws Exception
-     */
-    protected function validateDefault($value)
-    {
-        if (empty($value)) {
-            throw new Exception("Empty email default");
-        }
-
-        if (filter_var($value, FILTER_VALIDATE_EMAIL) === false) {
-            throw new Exception("Invalid email default value: '{$value}'");
-        }
-
-        return $value;
-    }
-
-    public static function getFormats()
-    {
-        return self::$formats;
-    }
-
-    public static function setFormats(array $formats)
-    {
-        self::$formats = $formats;
-    }
+	const PATTERN = '\A[a-z0-9!#$%&\'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&\'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\z';
+
+	/**
+	 * List of formats recognized by this class
+	 * @var string[]
+	 */
+	private static $formats = array('email');
+
+	/**
+	 * Construct and set up the regular expression for this type
+	 *
+	 * @param AbstractObject $parent
+	 * @param string $definition
+	 */
+	public function __construct(AbstractObject $parent, $definition)
+	{
+		$this->pattern = self::PATTERN;
+
+		parent::__construct($parent, $definition);
+	}
+
+	/**
+	 * Parse a type definition string, assuming it belongs to this type
+	 *
+	 * @param string $definition
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition)
+	{
+		$definition = self::trim($definition);
+
+		$match = array();
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
+			throw new Exception("Unparseable email definition: '{$definition}'");
+		}
+
+		if (!in_array(strtolower($match[1]), self::$formats)) {
+			throw new Exception("Not an email: '{$definition}'");
+		}
+
+		$this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
+	}
+
+	/**
+	 * Check (and optionally reformat) a default value
+	 *
+	 * @param string $value
+	 * @return string
+	 * @throws Exception
+	 */
+	protected function validateDefault($value)
+	{
+		if (empty($value)) {
+			throw new Exception("Empty email default");
+		}
+
+		if (filter_var($value, FILTER_VALIDATE_EMAIL) === false) {
+			throw new Exception("Invalid email default value: '{$value}'");
+		}
+
+		return $value;
+	}
+
+	public static function getFormats()
+	{
+		return self::$formats;
+	}
+
+	public static function setFormats(array $formats)
+	{
+		self::$formats = $formats;
+	}
 
 }

SwaggerGen/Swagger/Type/Custom/Ipv4Type.php

Indentation +72 added lines, -72 removed lines

@@ -17,77 +17,77 @@
 class Ipv4Type extends StringType implements ICustomType
 {
 
-    const PATTERN = '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.|$)){4}$';
-
-    /**
-     * List of formats recognized by this class
-     * @var string[]
-     */
-    private static $formats = array('ipv4');
-
-    /**
-     * Construct and set up the regular expression for this type
-     *
-     * @param AbstractObject $parent
-     * @param string $definition
-     */
-    public function __construct(AbstractObject $parent, $definition)
-    {
-        $this->pattern = self::PATTERN;
-
-        parent::__construct($parent, $definition);
-    }
-
-    /**
-     * Parse a type definition string, assuming it belongs to this type
-     *
-     * @param string $definition
-     * @throws Exception
-     */
-    protected function parseDefinition($definition)
-    {
-        $definition = self::trim($definition);
-
-        $match = array();
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
-            throw new Exception("Unparseable IPv4 definition: '{$definition}'");
-        }
-
-        if (!in_array(strtolower($match[1]), self::$formats)) {
-            throw new Exception("Not an IPv4: '{$definition}'");
-        }
-
-        $this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
-    }
-
-    /**
-     * Check (and optionally reformat) a default value
-     *
-     * @param string $value
-     * @return string
-     * @throws Exception
-     */
-    protected function validateDefault($value)
-    {
-        if (empty($value)) {
-            throw new Exception("Empty IPv4 default");
-        }
-
-        if (filter_var($value, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) === false) {
-            throw new Exception("Invalid IPv4 default value: '{$value}'");
-        }
-
-        return $value;
-    }
-
-    public static function getFormats()
-    {
-        return self::$formats;
-    }
-
-    public static function setFormats(array $formats)
-    {
-        self::$formats = $formats;
-    }
+	const PATTERN = '^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\\.|$)){4}$';
+
+	/**
+	 * List of formats recognized by this class
+	 * @var string[]
+	 */
+	private static $formats = array('ipv4');
+
+	/**
+	 * Construct and set up the regular expression for this type
+	 *
+	 * @param AbstractObject $parent
+	 * @param string $definition
+	 */
+	public function __construct(AbstractObject $parent, $definition)
+	{
+		$this->pattern = self::PATTERN;
+
+		parent::__construct($parent, $definition);
+	}
+
+	/**
+	 * Parse a type definition string, assuming it belongs to this type
+	 *
+	 * @param string $definition
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition)
+	{
+		$definition = self::trim($definition);
+
+		$match = array();
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
+			throw new Exception("Unparseable IPv4 definition: '{$definition}'");
+		}
+
+		if (!in_array(strtolower($match[1]), self::$formats)) {
+			throw new Exception("Not an IPv4: '{$definition}'");
+		}
+
+		$this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
+	}
+
+	/**
+	 * Check (and optionally reformat) a default value
+	 *
+	 * @param string $value
+	 * @return string
+	 * @throws Exception
+	 */
+	protected function validateDefault($value)
+	{
+		if (empty($value)) {
+			throw new Exception("Empty IPv4 default");
+		}
+
+		if (filter_var($value, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4) === false) {
+			throw new Exception("Invalid IPv4 default value: '{$value}'");
+		}
+
+		return $value;
+	}
+
+	public static function getFormats()
+	{
+		return self::$formats;
+	}
+
+	public static function setFormats(array $formats)
+	{
+		self::$formats = $formats;
+	}
 
 }

SwaggerGen/Swagger/Type/Custom/Ipv6Type.php

Indentation +72 added lines, -72 removed lines

@@ -17,77 +17,77 @@
 class Ipv6Type extends StringType implements ICustomType
 {
 
-    const PATTERN = '(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))';
-
-    /**
-     * List of formats recognized by this class
-     * @var string[]
-     */
-    private static $formats = array('ipv6');
-
-    /**
-     * Construct and set up the regular expression for this type
-     *
-     * @param AbstractObject $parent
-     * @param string $definition
-     */
-    public function __construct(AbstractObject $parent, $definition)
-    {
-        $this->pattern = self::PATTERN;
-
-        parent::__construct($parent, $definition);
-    }
-
-    /**
-     * Parse a type definition string, assuming it belongs to this type
-     *
-     * @param string $definition
-     * @throws Exception
-     */
-    protected function parseDefinition($definition)
-    {
-        $definition = self::trim($definition);
-
-        $match = array();
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
-            throw new Exception("Unparseable IPv6 definition: '{$definition}'");
-        }
-
-        if (!in_array(strtolower($match[1]), self::$formats)) {
-            throw new Exception("Not an IPv6: '{$definition}'");
-        }
-
-        $this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
-    }
-
-    /**
-     * Check (and optionally reformat) a default value
-     *
-     * @param string $value
-     * @return string
-     * @throws Exception
-     */
-    protected function validateDefault($value)
-    {
-        if (empty($value)) {
-            throw new Exception("Empty IPv6 default");
-        }
-
-        if (filter_var($value, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) === false) {
-            throw new Exception("Invalid IPv6 default value: '{$value}'");
-        }
-
-        return $value;
-    }
-
-    public static function getFormats()
-    {
-        return self::$formats;
-    }
-
-    public static function setFormats(array $formats)
-    {
-        self::$formats = $formats;
-    }
+	const PATTERN = '(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))';
+
+	/**
+	 * List of formats recognized by this class
+	 * @var string[]
+	 */
+	private static $formats = array('ipv6');
+
+	/**
+	 * Construct and set up the regular expression for this type
+	 *
+	 * @param AbstractObject $parent
+	 * @param string $definition
+	 */
+	public function __construct(AbstractObject $parent, $definition)
+	{
+		$this->pattern = self::PATTERN;
+
+		parent::__construct($parent, $definition);
+	}
+
+	/**
+	 * Parse a type definition string, assuming it belongs to this type
+	 *
+	 * @param string $definition
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition)
+	{
+		$definition = self::trim($definition);
+
+		$match = array();
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT . self::REGEX_END, $definition, $match) !== 1) {
+			throw new Exception("Unparseable IPv6 definition: '{$definition}'");
+		}
+
+		if (!in_array(strtolower($match[1]), self::$formats)) {
+			throw new Exception("Not an IPv6: '{$definition}'");
+		}
+
+		$this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
+	}
+
+	/**
+	 * Check (and optionally reformat) a default value
+	 *
+	 * @param string $value
+	 * @return string
+	 * @throws Exception
+	 */
+	protected function validateDefault($value)
+	{
+		if (empty($value)) {
+			throw new Exception("Empty IPv6 default");
+		}
+
+		if (filter_var($value, FILTER_VALIDATE_IP, FILTER_FLAG_IPV6) === false) {
+			throw new Exception("Invalid IPv6 default value: '{$value}'");
+		}
+
+		return $value;
+	}
+
+	public static function getFormats()
+	{
+		return self::$formats;
+	}
+
+	public static function setFormats(array $formats)
+	{
+		self::$formats = $formats;
+	}
 
 }

SwaggerGen/Swagger/Type/ArrayType.php

Indentation +176 added lines, -176 removed lines

@@ -16,181 +16,181 @@
 class ArrayType extends AbstractType
 {
 
-    const REGEX_ARRAY_CONTENT = '(?:(\[)(.*)\])?';
-
-    private static $collectionFormats = array(
-        'array' => 'csv',
-        'csv' => 'csv',
-        'ssv' => 'ssv',
-        'tsv' => 'tsv',
-        'pipes' => 'pipes',
-        'multi' => 'multi',
-    );
-
-    /**
-     * @var AbstractType
-     */
-    private $Items = null;
-    private $minItems = null;
-    private $maxItems = null;
-    private $collectionFormat = null;
-
-    /**
-     * @throws Exception
-     */
-    protected function parseDefinition($definition)
-    {
-        $definition = self::trim($definition);
-        $match = array();
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
-            $match[1] = strtolower($match[1]);
-        } elseif (preg_match(self::REGEX_START . self::REGEX_ARRAY_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
-            $match[1] = 'array';
-        } else {
-            throw new Exception('Unparseable array definition: \'' . $definition . '\'');
-        }
-
-        $this->parseFormat($definition, $match);
-        $this->parseItems($definition, $match);
-        $this->parseRange($definition, $match);
-    }
-
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     * @throws Exception
-     */
-    private function parseFormat($definition, $match)
-    {
-        $type = strtolower($match[1]);
-        if (!isset(self::$collectionFormats[$type])) {
-            throw new Exception("Not an array: '{$definition}'");
-        }
-
-        if ($type === 'multi') {
-            $parent = $this->getParent();
-            if (!($parent instanceof Parameter) || !$parent->isMulti()) {
-                throw new Exception("Multi array only allowed on query or form parameter: '{$definition}'");
-            }
-        }
-
-        $this->collectionFormat = self::$collectionFormats[$type];
-    }
-
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     */
-    private function parseItems($definition, $match)
-    {
-        if (!empty($match[2])) {
-            $this->Items = $this->validateItems($match[2]);
-        }
-    }
-
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     */
-    private function parseRange($definition, $match)
-    {
-        if (!empty($match[3])) {
-            if ($match[4] === '' && $match[5] === '') {
-                throw new Exception("Empty array range: '{$definition}'");
-            }
-
-            $exclusiveMinimum = $match[3] == '<';
-            $this->minItems = $match[4] === '' ? null : intval($match[4]);
-            $this->maxItems = $match[5] === '' ? null : intval($match[5]);
-            $exclusiveMaximum = isset($match[6]) ? ($match[6] == '>') : null;
-            if ($this->minItems && $this->maxItems && $this->minItems > $this->maxItems) {
-                self::swap($this->minItems, $this->maxItems);
-                self::swap($exclusiveMinimum, $exclusiveMaximum);
-            }
-            $this->minItems = $this->minItems === null ? null : max(0, $exclusiveMinimum ? $this->minItems + 1 : $this->minItems);
-            $this->maxItems = $this->maxItems === null ? null : max(0, $exclusiveMaximum ? $this->maxItems - 1 : $this->maxItems);
-        }
-    }
-
-    /**
-     * @param string $command The comment command
-     * @param string $data Any data added after the command
-     * @return AbstractType|boolean
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     */
-    public function handleCommand($command, $data = null)
-    {
-        if ($this->Items) {
-            $return = $this->Items->handleCommand($command, $data);
-            if ($return) {
-                return $return;
-            }
-        }
-
-        switch (strtolower($command)) {
-            case 'min':
-                $this->minItems = intval($data);
-                if ($this->minItems < 0) {
-                    throw new Exception("Minimum less than zero: '{$data}'");
-                }
-                if ($this->maxItems !== null && $this->minItems > $this->maxItems) {
-                    throw new Exception("Minimum greater than maximum: '{$data}'");
-                }
-                return $this;
-
-            case 'max':
-                $this->maxItems = intval($data);
-                if ($this->minItems !== null && $this->minItems > $this->maxItems) {
-                    throw new Exception("Maximum less than minimum: '{$data}'");
-                }
-                if ($this->maxItems < 0) {
-                    throw new Exception("Maximum less than zero: '{$data}'");
-                }
-                return $this;
-
-            case 'items':
-                $this->Items = $this->validateItems($data);
-                return $this->Items;
-        }
-
-        return parent::handleCommand($command, $data);
-    }
-
-    public function toArray()
-    {
-        return self::arrayFilterNull(array_merge(array(
-            'type' => 'array',
-            'items' => empty($this->Items) ? null : $this->Items->toArray(),
-            'collectionFormat' => $this->collectionFormat == 'csv' ? null : $this->collectionFormat,
-            'minItems' => $this->minItems,
-            'maxItems' => $this->maxItems,
-        ), parent::toArray()));
-    }
-
-    /**
-     * @throws Exception
-     */
-    private function validateItems($items)
-    {
-        if (empty($items)) {
-            throw new Exception("Empty items definition: '{$items}'");
-        }
-
-        return self::typeFactory($this, $items, "Unparseable items definition: '%s'");
-    }
-
-    public function __toString()
-    {
-        return __CLASS__;
-    }
+	const REGEX_ARRAY_CONTENT = '(?:(\[)(.*)\])?';
+
+	private static $collectionFormats = array(
+		'array' => 'csv',
+		'csv' => 'csv',
+		'ssv' => 'ssv',
+		'tsv' => 'tsv',
+		'pipes' => 'pipes',
+		'multi' => 'multi',
+	);
+
+	/**
+	 * @var AbstractType
+	 */
+	private $Items = null;
+	private $minItems = null;
+	private $maxItems = null;
+	private $collectionFormat = null;
+
+	/**
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition)
+	{
+		$definition = self::trim($definition);
+		$match = array();
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
+			$match[1] = strtolower($match[1]);
+		} elseif (preg_match(self::REGEX_START . self::REGEX_ARRAY_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
+			$match[1] = 'array';
+		} else {
+			throw new Exception('Unparseable array definition: \'' . $definition . '\'');
+		}
+
+		$this->parseFormat($definition, $match);
+		$this->parseItems($definition, $match);
+		$this->parseRange($definition, $match);
+	}
+
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 * @throws Exception
+	 */
+	private function parseFormat($definition, $match)
+	{
+		$type = strtolower($match[1]);
+		if (!isset(self::$collectionFormats[$type])) {
+			throw new Exception("Not an array: '{$definition}'");
+		}
+
+		if ($type === 'multi') {
+			$parent = $this->getParent();
+			if (!($parent instanceof Parameter) || !$parent->isMulti()) {
+				throw new Exception("Multi array only allowed on query or form parameter: '{$definition}'");
+			}
+		}
+
+		$this->collectionFormat = self::$collectionFormats[$type];
+	}
+
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 */
+	private function parseItems($definition, $match)
+	{
+		if (!empty($match[2])) {
+			$this->Items = $this->validateItems($match[2]);
+		}
+	}
+
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 */
+	private function parseRange($definition, $match)
+	{
+		if (!empty($match[3])) {
+			if ($match[4] === '' && $match[5] === '') {
+				throw new Exception("Empty array range: '{$definition}'");
+			}
+
+			$exclusiveMinimum = $match[3] == '<';
+			$this->minItems = $match[4] === '' ? null : intval($match[4]);
+			$this->maxItems = $match[5] === '' ? null : intval($match[5]);
+			$exclusiveMaximum = isset($match[6]) ? ($match[6] == '>') : null;
+			if ($this->minItems && $this->maxItems && $this->minItems > $this->maxItems) {
+				self::swap($this->minItems, $this->maxItems);
+				self::swap($exclusiveMinimum, $exclusiveMaximum);
+			}
+			$this->minItems = $this->minItems === null ? null : max(0, $exclusiveMinimum ? $this->minItems + 1 : $this->minItems);
+			$this->maxItems = $this->maxItems === null ? null : max(0, $exclusiveMaximum ? $this->maxItems - 1 : $this->maxItems);
+		}
+	}
+
+	/**
+	 * @param string $command The comment command
+	 * @param string $data Any data added after the command
+	 * @return AbstractType|boolean
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 */
+	public function handleCommand($command, $data = null)
+	{
+		if ($this->Items) {
+			$return = $this->Items->handleCommand($command, $data);
+			if ($return) {
+				return $return;
+			}
+		}
+
+		switch (strtolower($command)) {
+			case 'min':
+				$this->minItems = intval($data);
+				if ($this->minItems < 0) {
+					throw new Exception("Minimum less than zero: '{$data}'");
+				}
+				if ($this->maxItems !== null && $this->minItems > $this->maxItems) {
+					throw new Exception("Minimum greater than maximum: '{$data}'");
+				}
+				return $this;
+
+			case 'max':
+				$this->maxItems = intval($data);
+				if ($this->minItems !== null && $this->minItems > $this->maxItems) {
+					throw new Exception("Maximum less than minimum: '{$data}'");
+				}
+				if ($this->maxItems < 0) {
+					throw new Exception("Maximum less than zero: '{$data}'");
+				}
+				return $this;
+
+			case 'items':
+				$this->Items = $this->validateItems($data);
+				return $this->Items;
+		}
+
+		return parent::handleCommand($command, $data);
+	}
+
+	public function toArray()
+	{
+		return self::arrayFilterNull(array_merge(array(
+			'type' => 'array',
+			'items' => empty($this->Items) ? null : $this->Items->toArray(),
+			'collectionFormat' => $this->collectionFormat == 'csv' ? null : $this->collectionFormat,
+			'minItems' => $this->minItems,
+			'maxItems' => $this->maxItems,
+		), parent::toArray()));
+	}
+
+	/**
+	 * @throws Exception
+	 */
+	private function validateItems($items)
+	{
+		if (empty($items)) {
+			throw new Exception("Empty items definition: '{$items}'");
+		}
+
+		return self::typeFactory($this, $items, "Unparseable items definition: '%s'");
+	}
+
+	public function __toString()
+	{
+		return __CLASS__;
+	}
 
 }

SwaggerGen/Swagger/Type/AbstractRegexType.php

Indentation +46 added lines, -46 removed lines

@@ -16,61 +16,61 @@
 class AbstractRegexType extends StringType
 {
 
-    const REGEX_DEFAULT_START = '(?:=(';
-    const REGEX_DEFAULT_END = '))?';
+	const REGEX_DEFAULT_START = '(?:=(';
+	const REGEX_DEFAULT_END = '))?';
 
-    /**
-     * The raw regular expression to use.
-     * Exclude start (`^`) and end (`$`) anchors.
-     * @var string
-     */
-    private $regex;
+	/**
+	 * The raw regular expression to use.
+	 * Exclude start (`^`) and end (`$`) anchors.
+	 * @var string
+	 */
+	private $regex;
 
-    /**
-     * Construct and set up the regular expression for this type
-     *
-     * @param AbstractObject $parent
-     * @param string $definition
-     * @param string $format Name of the string format
-     * @param string $regex Regular expression to use as the format and for default validation
-     */
-    public function __construct(AbstractObject $parent, $definition, $format, $regex)
-    {
-        $this->format = $format;
-        $this->regex = $regex;
+	/**
+	 * Construct and set up the regular expression for this type
+	 *
+	 * @param AbstractObject $parent
+	 * @param string $definition
+	 * @param string $format Name of the string format
+	 * @param string $regex Regular expression to use as the format and for default validation
+	 */
+	public function __construct(AbstractObject $parent, $definition, $format, $regex)
+	{
+		$this->format = $format;
+		$this->regex = $regex;
 
-        parent::__construct($parent, $definition);
-    }
+		parent::__construct($parent, $definition);
+	}
 
-    /**
-     * @throws Exception
-     */
-    protected function parseDefinition($definition)
-    {
-        $definition = self::trim($definition);
+	/**
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition)
+	{
+		$definition = self::trim($definition);
 
-        $match = array();
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT_START . $this->regex . self::REGEX_DEFAULT_END . self::REGEX_END, $definition, $match) !== 1) {
-            throw new Exception('Unparseable ' . $this->format . ' definition: \'' . $definition . '\'');
-        }
+		$match = array();
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_DEFAULT_START . $this->regex . self::REGEX_DEFAULT_END . self::REGEX_END, $definition, $match) !== 1) {
+			throw new Exception('Unparseable ' . $this->format . ' definition: \'' . $definition . '\'');
+		}
 
-        if (strtolower($match[1] !== $this->format)) {
-            throw new Exception('Not a ' . $this->format . ': \'' . $definition . '\'');
-        }
+		if (strtolower($match[1] !== $this->format)) {
+			throw new Exception('Not a ' . $this->format . ': \'' . $definition . '\'');
+		}
 
-        $this->pattern = '^' . $this->regex . '$';
-        $this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
-    }
+		$this->pattern = '^' . $this->regex . '$';
+		$this->default = isset($match[2]) && $match[2] !== '' ? $this->validateDefault($match[2]) : null;
+	}
 
-    protected function validateDefault($value)
-    {
-        $value = parent::validateDefault($value);
+	protected function validateDefault($value)
+	{
+		$value = parent::validateDefault($value);
 
-        if (preg_match('/' . $this->pattern . '/', $value) !== 1) {
-            throw new Exception('Invalid ' . $this->format . ' default value');
-        }
+		if (preg_match('/' . $this->pattern . '/', $value) !== 1) {
+			throw new Exception('Invalid ' . $this->format . ' default value');
+		}
 
-        return $value;
-    }
+		return $value;
+	}
 
 }

SwaggerGen/Swagger/Type/ObjectType.php

Indentation +250 added lines, -250 removed lines

@@ -15,281 +15,281 @@
 class ObjectType extends AbstractType
 {
 
-    const REGEX_OBJECT_CONTENT = '(?:(\{)(.*)\})?';
-    const REGEX_PROP_START = '/^';
-    const REGEX_PROP_NAME = '([^?!:]+)';
-    const REGEX_PROP_REQUIRED = '([\?!])?';
-    const REGEX_PROP_ASSIGN = ':';
-    const REGEX_PROP_DEFINITION = '(.+)';
-    const REGEX_PROP_ADDITIONAL = '\.\.\.(!|.+)?';
-    const REGEX_PROP_END = '$/';
+	const REGEX_OBJECT_CONTENT = '(?:(\{)(.*)\})?';
+	const REGEX_PROP_START = '/^';
+	const REGEX_PROP_NAME = '([^?!:]+)';
+	const REGEX_PROP_REQUIRED = '([\?!])?';
+	const REGEX_PROP_ASSIGN = ':';
+	const REGEX_PROP_DEFINITION = '(.+)';
+	const REGEX_PROP_ADDITIONAL = '\.\.\.(!|.+)?';
+	const REGEX_PROP_END = '$/';
 
-    private $minProperties = null;
-    private $maxProperties = null;
-    private $discriminator = null;
-    private $additionalProperties = null;
-    private $required = array();
+	private $minProperties = null;
+	private $maxProperties = null;
+	private $discriminator = null;
+	private $additionalProperties = null;
+	private $required = array();
 
-    /**
-     * @var Property[]
-     */
-    private $properties = array();
+	/**
+	 * @var Property[]
+	 */
+	private $properties = array();
 
-    /**
-     * @var Property
-     */
-    private $mostRecentProperty = null;
+	/**
+	 * @var Property
+	 */
+	private $mostRecentProperty = null;
 
-    /**
-     * @throws Exception
-     */
-    protected function parseDefinition($definition)
-    {
-        $definition = self::trim($definition);
+	/**
+	 * @throws Exception
+	 */
+	protected function parseDefinition($definition)
+	{
+		$definition = self::trim($definition);
 
-        $match = array();
-        if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
-            $match[1] = strtolower($match[1]);
-        } elseif (preg_match(self::REGEX_START . self::REGEX_OBJECT_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
-            $match[1] = 'object';
-        } else {
-            throw new Exception('Unparseable object definition: \'' . $definition . '\'');
-        }
+		$match = array();
+		if (preg_match(self::REGEX_START . self::REGEX_FORMAT . self::REGEX_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
+			$match[1] = strtolower($match[1]);
+		} elseif (preg_match(self::REGEX_START . self::REGEX_OBJECT_CONTENT . self::REGEX_RANGE . self::REGEX_END, $definition, $match) === 1) {
+			$match[1] = 'object';
+		} else {
+			throw new Exception('Unparseable object definition: \'' . $definition . '\'');
+		}
 
-        $this->parseFormat($definition, $match);
-        $this->parseProperties($definition, $match);
-        $this->parseRange($definition, $match);
-    }
+		$this->parseFormat($definition, $match);
+		$this->parseProperties($definition, $match);
+		$this->parseRange($definition, $match);
+	}
 
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     */
-    private function parseFormat($definition, $match)
-    {
-        if (strtolower($match[1]) !== 'object') {
-            throw new Exception("Not an object: '{$definition}'");
-        }
-    }
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 */
+	private function parseFormat($definition, $match)
+	{
+		if (strtolower($match[1]) !== 'object') {
+			throw new Exception("Not an object: '{$definition}'");
+		}
+	}
 
-    /**
-     * @param AbstractType|bool $type
-     * @return void
-     * @throws Exception
-     */
-    private function setAdditionalProperties($type)
-    {
-        if ($this->additionalProperties !== null) {
-            throw new Exception('Additional properties may only be set once');
-        }
-        $this->additionalProperties = $type;
-    }
+	/**
+	 * @param AbstractType|bool $type
+	 * @return void
+	 * @throws Exception
+	 */
+	private function setAdditionalProperties($type)
+	{
+		if ($this->additionalProperties !== null) {
+			throw new Exception('Additional properties may only be set once');
+		}
+		$this->additionalProperties = $type;
+	}
 
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     */
-    private function parseProperties($definition, $match)
-    {
-        if (empty($match[2])) {
-            return;
-        }
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 */
+	private function parseProperties($definition, $match)
+	{
+		if (empty($match[2])) {
+			return;
+		}
 
-        while (($property = self::parseListItem($match[2])) !== '') {
-            $prop_match = array();
-            if (preg_match(self::REGEX_PROP_START . self::REGEX_PROP_ADDITIONAL . self::REGEX_PROP_END, $property, $prop_match) === 1) {
-                if (empty($prop_match[1])) {
-                    $this->setAdditionalProperties(true);
-                } else if ($prop_match[1] === '!') {
-                    $this->setAdditionalProperties(false);
-                } else {
-                    $this->setAdditionalProperties(self::typeFactory($this, $prop_match[1], "Unparseable additional properties definition: '...%s'"));
-                }
-                continue;
-            }
-            if (preg_match(self::REGEX_PROP_START . self::REGEX_PROP_NAME . self::REGEX_PROP_REQUIRED . self::REGEX_PROP_ASSIGN . self::REGEX_PROP_DEFINITION . self::REGEX_PROP_END, $property, $prop_match) !== 1) {
-                throw new Exception("Unparseable property definition: '{$property}'");
-            }
-            $this->properties[$prop_match[1]] = new Property($this, $prop_match[3]);
-            if ($prop_match[2] !== '!' && $prop_match[2] !== '?') {
-                $this->required[$prop_match[1]] = true;
-            }
-        }
+		while (($property = self::parseListItem($match[2])) !== '') {
+			$prop_match = array();
+			if (preg_match(self::REGEX_PROP_START . self::REGEX_PROP_ADDITIONAL . self::REGEX_PROP_END, $property, $prop_match) === 1) {
+				if (empty($prop_match[1])) {
+					$this->setAdditionalProperties(true);
+				} else if ($prop_match[1] === '!') {
+					$this->setAdditionalProperties(false);
+				} else {
+					$this->setAdditionalProperties(self::typeFactory($this, $prop_match[1], "Unparseable additional properties definition: '...%s'"));
+				}
+				continue;
+			}
+			if (preg_match(self::REGEX_PROP_START . self::REGEX_PROP_NAME . self::REGEX_PROP_REQUIRED . self::REGEX_PROP_ASSIGN . self::REGEX_PROP_DEFINITION . self::REGEX_PROP_END, $property, $prop_match) !== 1) {
+				throw new Exception("Unparseable property definition: '{$property}'");
+			}
+			$this->properties[$prop_match[1]] = new Property($this, $prop_match[3]);
+			if ($prop_match[2] !== '!' && $prop_match[2] !== '?') {
+				$this->required[$prop_match[1]] = true;
+			}
+		}
 
-    }
+	}
 
-    /**
-     * @param string $definition
-     * @param string[] $match
-     * @throws Exception
-     */
-    private function parseRange($definition, $match)
-    {
-        if (!empty($match[3])) {
-            if ($match[4] === '' && $match[5] === '') {
-                throw new Exception("Empty object range: '{$definition}'");
-            }
+	/**
+	 * @param string $definition
+	 * @param string[] $match
+	 * @throws Exception
+	 */
+	private function parseRange($definition, $match)
+	{
+		if (!empty($match[3])) {
+			if ($match[4] === '' && $match[5] === '') {
+				throw new Exception("Empty object range: '{$definition}'");
+			}
 
-            $exclusiveMinimum = $match[3] == '<';
-            $this->minProperties = $match[4] === '' ? null : intval($match[4]);
-            $this->maxProperties = $match[5] === '' ? null : intval($match[5]);
-            $exclusiveMaximum = isset($match[6]) ? ($match[6] == '>') : null;
-            if ($this->minProperties && $this->maxProperties && $this->minProperties > $this->maxProperties) {
-                self::swap($this->minProperties, $this->maxProperties);
-                self::swap($exclusiveMinimum, $exclusiveMaximum);
-            }
-            $this->minProperties = $this->minProperties === null ? null : max(0, $exclusiveMinimum ? $this->minProperties + 1 : $this->minProperties);
-            $this->maxProperties = $this->maxProperties === null ? null : max(0, $exclusiveMaximum ? $this->maxProperties - 1 : $this->maxProperties);
-        }
-    }
+			$exclusiveMinimum = $match[3] == '<';
+			$this->minProperties = $match[4] === '' ? null : intval($match[4]);
+			$this->maxProperties = $match[5] === '' ? null : intval($match[5]);
+			$exclusiveMaximum = isset($match[6]) ? ($match[6] == '>') : null;
+			if ($this->minProperties && $this->maxProperties && $this->minProperties > $this->maxProperties) {
+				self::swap($this->minProperties, $this->maxProperties);
+				self::swap($exclusiveMinimum, $exclusiveMaximum);
+			}
+			$this->minProperties = $this->minProperties === null ? null : max(0, $exclusiveMinimum ? $this->minProperties + 1 : $this->minProperties);
+			$this->maxProperties = $this->maxProperties === null ? null : max(0, $exclusiveMaximum ? $this->maxProperties - 1 : $this->maxProperties);
+		}
+	}
 
-    /**
-     * @param string|false $discriminator
-     * @throws Exception
-     * @throws Exception
-     */
-    private function setDiscriminator($discriminator)
-    {
-        if (!empty($this->discriminator)) {
-            throw new Exception("Discriminator may only be set once, "
-                . "trying to change it "
-                . "from '{$this->discriminator}' "
-                . "to '{$discriminator}'");
-        }
-        if (isset($this->properties[$discriminator]) && empty($this->required[$discriminator])) {
-            throw new Exception("Discriminator must be a required property, "
-                . "property '{$discriminator}' is not required");
-        }
-        $this->discriminator = $discriminator;
-    }
+	/**
+	 * @param string|false $discriminator
+	 * @throws Exception
+	 * @throws Exception
+	 */
+	private function setDiscriminator($discriminator)
+	{
+		if (!empty($this->discriminator)) {
+			throw new Exception("Discriminator may only be set once, "
+				. "trying to change it "
+				. "from '{$this->discriminator}' "
+				. "to '{$discriminator}'");
+		}
+		if (isset($this->properties[$discriminator]) && empty($this->required[$discriminator])) {
+			throw new Exception("Discriminator must be a required property, "
+				. "property '{$discriminator}' is not required");
+		}
+		$this->discriminator = $discriminator;
+	}
 
-    /**
-     * @param string $command The comment command
-     * @param string $data Any data added after the command
-     * @return AbstractType|boolean
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     * @throws Exception
-     */
-    public function handleCommand($command, $data = null)
-    {
-        switch (strtolower($command)) {
-            // type name description...
-            case 'additionalproperties':
-                $value = self::wordShift($data);
-                if (is_bool($value)) {
-                    $type = $value;
-                } else if ($value === 'false') {
-                    $type = false;
-                } else if ($value === 'true') {
-                    $type = true;
-                } else {
-                    $type = self::typeFactory($this, $value, "Unparseable additional properties definition: '%s'");
-                }
-                $this->setAdditionalProperties($type);
-                return $this;
-            case 'discriminator':
-                $discriminator = self::wordShift($data);
-                $this->setDiscriminator($discriminator);
-                return $this;
-            case 'property':
-            case 'property?':
-            case 'property!':
-                $definition = self::wordShift($data);
-                if (empty($definition)) {
-                    throw new Exception("Missing property definition");
-                }
+	/**
+	 * @param string $command The comment command
+	 * @param string $data Any data added after the command
+	 * @return AbstractType|boolean
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 * @throws Exception
+	 */
+	public function handleCommand($command, $data = null)
+	{
+		switch (strtolower($command)) {
+			// type name description...
+			case 'additionalproperties':
+				$value = self::wordShift($data);
+				if (is_bool($value)) {
+					$type = $value;
+				} else if ($value === 'false') {
+					$type = false;
+				} else if ($value === 'true') {
+					$type = true;
+				} else {
+					$type = self::typeFactory($this, $value, "Unparseable additional properties definition: '%s'");
+				}
+				$this->setAdditionalProperties($type);
+				return $this;
+			case 'discriminator':
+				$discriminator = self::wordShift($data);
+				$this->setDiscriminator($discriminator);
+				return $this;
+			case 'property':
+			case 'property?':
+			case 'property!':
+				$definition = self::wordShift($data);
+				if (empty($definition)) {
+					throw new Exception("Missing property definition");
+				}
 
-                $name = self::wordShift($data);
-                if (empty($name)) {
-                    throw new Exception("Missing property name: '{$definition}'");
-                }
+				$name = self::wordShift($data);
+				if (empty($name)) {
+					throw new Exception("Missing property name: '{$definition}'");
+				}
 
-                $readOnly = null;
-                $required = false;
-                $propertySuffix = substr($command, -1);
-                if ($propertySuffix === '!') {
-                    $readOnly = true;
-                } else if ($propertySuffix !== '?') {
-                    $required = true;
-                }
+				$readOnly = null;
+				$required = false;
+				$propertySuffix = substr($command, -1);
+				if ($propertySuffix === '!') {
+					$readOnly = true;
+				} else if ($propertySuffix !== '?') {
+					$required = true;
+				}
 
-                if (($name === $this->discriminator) && !$required) {
-                    throw new Exception("Discriminator must be a required property, "
-                        . "property '{$name}' is not required");
-                }
+				if (($name === $this->discriminator) && !$required) {
+					throw new Exception("Discriminator must be a required property, "
+						. "property '{$name}' is not required");
+				}
 
-                unset($this->required[$name]);
-                if ($required) {
-                    $this->required[$name] = true;
-                }
+				unset($this->required[$name]);
+				if ($required) {
+					$this->required[$name] = true;
+				}
 
-                $this->mostRecentProperty = new Property($this, $definition, $data, $readOnly);
-                $this->properties[$name] = $this->mostRecentProperty;
-                return $this;
+				$this->mostRecentProperty = new Property($this, $definition, $data, $readOnly);
+				$this->properties[$name] = $this->mostRecentProperty;
+				return $this;
 
-            case 'min':
-                $this->minProperties = intval($data);
-                if ($this->minProperties < 0) {
-                    throw new Exception("Minimum less than zero: '{$data}'");
-                }
-                if ($this->maxProperties !== null && $this->minProperties > $this->maxProperties) {
-                    throw new Exception("Minimum greater than maximum: '{$data}'");
-                }
-                $this->minProperties = intval($data);
-                return $this;
+			case 'min':
+				$this->minProperties = intval($data);
+				if ($this->minProperties < 0) {
+					throw new Exception("Minimum less than zero: '{$data}'");
+				}
+				if ($this->maxProperties !== null && $this->minProperties > $this->maxProperties) {
+					throw new Exception("Minimum greater than maximum: '{$data}'");
+				}
+				$this->minProperties = intval($data);
+				return $this;
 
-            case 'max':
-                $this->maxProperties = intval($data);
-                if ($this->minProperties !== null && $this->minProperties > $this->maxProperties) {
-                    throw new Exception("Maximum less than minimum: '{$data}'");
-                }
-                if ($this->maxProperties < 0) {
-                    throw new Exception("Maximum less than zero: '{$data}'");
-                }
-                return $this;
-        }
+			case 'max':
+				$this->maxProperties = intval($data);
+				if ($this->minProperties !== null && $this->minProperties > $this->maxProperties) {
+					throw new Exception("Maximum less than minimum: '{$data}'");
+				}
+				if ($this->maxProperties < 0) {
+					throw new Exception("Maximum less than zero: '{$data}'");
+				}
+				return $this;
+		}
 
-        // Pass through to most recent Property
-        if ($this->mostRecentProperty && $this->mostRecentProperty->handleCommand($command, $data)) {
-            return $this;
-        }
+		// Pass through to most recent Property
+		if ($this->mostRecentProperty && $this->mostRecentProperty->handleCommand($command, $data)) {
+			return $this;
+		}
 
-        return parent::handleCommand($command, $data);
-    }
+		return parent::handleCommand($command, $data);
+	}
 
-    public function toArray()
-    {
-        return self::arrayFilterNull(array_merge(array(
-            'type' => 'object',
-            'required' => array_keys($this->required),
-            'properties' => self::objectsToArray($this->properties),
-            'minProperties' => $this->minProperties,
-            'maxProperties' => $this->maxProperties,
-            'discriminator' => $this->discriminator,
-            'additionalProperties' => $this->additionalProperties instanceof AbstractType ? $this->additionalProperties->toArray() : $this->additionalProperties,
-        ), parent::toArray()));
-    }
+	public function toArray()
+	{
+		return self::arrayFilterNull(array_merge(array(
+			'type' => 'object',
+			'required' => array_keys($this->required),
+			'properties' => self::objectsToArray($this->properties),
+			'minProperties' => $this->minProperties,
+			'maxProperties' => $this->maxProperties,
+			'discriminator' => $this->discriminator,
+			'additionalProperties' => $this->additionalProperties instanceof AbstractType ? $this->additionalProperties->toArray() : $this->additionalProperties,
+		), parent::toArray()));
+	}
 
-    public function __toString()
-    {
-        return __CLASS__;
-    }
+	public function __toString()
+	{
+		return __CLASS__;
+	}
 
 }