gossi\swagger\Swagger

Complexity

Total Complexity

16

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	18

Test Coverage

Coverage

92.98%

Importance

Changes	5
Bugs	1	Features	0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	fromFile()	0	12	2
A	__construct()	0	4	1
B	parse()	0	27	2
A	toArray()	0	6	1
A	getVersion()	0	4	1
A	setVersion()	0	6	1
A	getInfo()	0	4	1
A	getHost()	0	4	1
A	setHost()	0	6	1
A	getBasePath()	0	4	1
A	setBasePath()	0	6	1
A	getPaths()	0	4	1
A	getDefinitions()	0	4	1
A	getSecurityDefinitions()	0	4	1

<?php

namespace gossi\swagger;

use gossi\swagger\parts\ConsumesPart;
use gossi\swagger\parts\ExtensionPart;
use gossi\swagger\parts\ExternalDocsPart;
use gossi\swagger\parts\ParametersPart;
use gossi\swagger\parts\ProducesPart;
use gossi\swagger\parts\ResponsesPart;
use gossi\swagger\parts\SchemesPart;
use gossi\swagger\parts\TagsPart;
use phootwork\collection\CollectionUtils;
use phootwork\collection\Map;
use phootwork\file\exception\FileNotFoundException;
use phootwork\file\File;
use phootwork\json\Json;
use phootwork\lang\Arrayable;
use gossi\swagger\collections\Paths;
use gossi\swagger\collections\Definitions;

class Swagger extends AbstractModel implements Arrayable
{
    use SchemesPart;
    use ConsumesPart;
    use ProducesPart;
    use TagsPart;
    use ParametersPart;
    use ResponsesPart;
    use ExternalDocsPart;
    use ExtensionPart;

    const T_INTEGER = 'integer';
    const T_NUMBER = 'number';
    const T_BOOLEAN = 'boolean';
    const T_STRING = 'string';
    const T_FILE = 'file';

    const F_INT32 = 'int32';
    const F_INT64 = 'int64';
    const F_FLOAT = 'float';
    const F_DOUBLE = 'double';
    const F_STRING = 'string';
    const F_BYTE = 'byte';
    const F_BINARY = 'binary';
    const F_DATE = 'date';
    const F_DATETIME = 'date-time';
    const F_PASSWORD = 'password';

    public static $METHODS = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head'];

    /** @var string */
    private $swagger = '2.0';

    /** @var Info */
    private $info;

    /** @var string */
    private $host;

    /** @var string */
    private $basePath;

    /** @var Paths */
    private $paths;

    /** @var Definitions */
    private $definitions;

    /** @var Map */
    private $securityDefinitions;

    /**
     * @param string $filename
     *
     * @throws FileNotFoundException
     * @throws JsonException
     *
     * @return static
     */
    public static function fromFile($filename)
    {
        $file = new File($filename);

        if (!$file->exists()) {
            throw new FileNotFoundException(sprintf('File not found at: %s', $filename));
        }

        $json = Json::decode($file->read());

        return new static($json);
    }

    public function __construct($contents = [])
    {
        $this->parse($contents);
    }

    private function parse($contents)
    {
        $data = CollectionUtils::toMap($contents);

        $this->swagger = $data->get('version', $this->swagger);
        $this->host = $data->get('host');
        $this->basePath = $data->get('basePath');
        $this->info = new Info($data->get('info', []));
        $this->paths = new Paths($data->get('paths'));
        $this->definitions = new Definitions($data->get('definitions', new Map()));

        // security schemes
        $this->securityDefinitions = $data->get('securityDefinitions', new Map());
        foreach ($this->securityDefinitions as $s => $def) {
            $this->securityDefinitions->set($s, new SecurityScheme($s, $def));
        }

        // parts
        $this->parseSchemes($data);
        $this->parseConsumes($data);
        $this->parseProduces($data);
        $this->parseTags($data);
        $this->parseParameters($data);
        $this->parseResponses($data);
        $this->parseExternalDocs($data);
        $this->parseExtensions($data);
    }

    public function toArray()
    {
        return $this->export('swagger', 'info', 'host', 'basePath', 'schemes', 'consumes', 'produces',
            'paths', 'definitions', 'parameters', 'responses', 'tags', 'externalDocs'
        );
    }

    /**
     * @return string
     */
    public function getVersion()
    {
        return $this->swagger;
    }

    /**
     * @param string $version
     *
     * @return $this
     */
    public function setVersion($version)
    {
        $this->swagger = $version;

        return $this;
    }

    /**
     * @return Info
     */
    public function getInfo()
    {
        return $this->info;
    }

    /**
     * @return string
     */
    public function getHost()
    {
        return $this->host;
    }

    /**
     * @param string $host
     *
     * @return $this
     */
    public function setHost($host)
    {
        $this->host = $host;

        return $this;
    }

    /**
     * @return string
     */
    public function getBasePath()
    {
        return $this->basePath;
    }

    /**
     * @param string $basePath
     *
     * @return $this
     */
    public function setBasePath($basePath)
    {
        $this->basePath = $basePath;

        return $this;
    }

    /**
     * @return Paths
     */
    public function getPaths()
    {
        return $this->paths;
    }

    /**
     * @return Map
     */
    public function getDefinitions()
    {
        return $this->definitions;
    }

    /**
     * @return Map
     */
    public function getSecurityDefinitions()
    {
        return $this->securityDefinitions;
    }

// 	/**
// 	 *
// 	 * @param Map $securityDefinitions        	
// 	 */
// 	public function setSecurityDefinitions(Map $securityDefinitions) {
// 		$this->securityDefinitions = $securityDefinitions;
// 		return $this;
// 	}
}