Swagger - Code Metrics - Inspection of "StatementException and more" - vanderlee/PHPSwaggerGen - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0ef921...49b538 )

by Martijn

created 2016-10-15 16:16 UTC

Swagger C

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	315
Duplicated Lines	14.29 %

Coupling/Cohesion

Components	1
Dependencies	10

Importance

Changes	5
Bugs	1	Features	0

Metric	Value
dl	45
loc	315
rs	5.7097
c	5
b	1
f	0
wmc	67
lcom	1
cbo	10

8 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	9	1
A	getSwagger()	0	4	1
A	getConsumes()	0	4	1
A	getSecurity()	0	8	2
D	handleCommand()	45	147	51
C	toArray()	0	40	7
A	__toString()	0	4	1
A	hasOperationId()	0	10	3

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like Swagger often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use Swagger, and based on these observations, apply Extract Interface, too.

<?php

namespace SwaggerGen\Swagger;

/**
 * Object representing the root level of a Swagger 2.0 document.
 *
 * @package    SwaggerGen
 * @author     Martijn van der Lee <[email protected]>
 * @copyright  2014-2016 Martijn van der Lee
 * @license    https://opensource.org/licenses/MIT MIT
 */
class Swagger extends AbstractDocumentableObject
{

	private $swagger = '2.0';
	private $host;
	private $basePath;

	/**
	 * @var Info $Info
	 */
	private $info;
	private $schemes = array();
	private $consumes = array();
	private $produces = array();

	/**
	 * @var \SwaggerGen\Swagger\Path[] $Paths
	 */
	private $paths = array();

	/**
	 * @var \SwaggerGen\Swagger\Schema[] $definitions
	 */
	private $definitions = array();

	/**
	 * @var \SwaggerGen\Swagger\IParameter[] $parameters
	 */
	private $parameters = array();

	/**
	 * @var \SwaggerGen\Swagger\Response[] $responses
	 */
	private $responses = array();

	/**
	 * @var Tag[] $Tags
	 */
	private $tags = array();

	/**
	 * Default tag for new endpoints/operations. Set by the api command.
	 * @var Tag
	 */
	private $defaultTag = null;
	private $securityDefinitions = array();
	private $security = array();

	/**
	 * @inheritDoc
	 * @param string $host
	 * @param string $basePath
	 */
	public function __construct($host = null, $basePath = null)
	{
		parent::__construct(null);

		$this->host = $host;
		$this->basePath = $basePath;

		$this->info = new Info($this);
	}

	/**
	 * @inheritDoc
	 */
	protected function getSwagger()
	{
		return $this;
	}

	/**
	 * Return all consumes
	 * @todo Deprecate in favour of a getConsume($name);
	 * @return string
	 */
	public function getConsumes()
	{
		return $this->consumes;
	}

	/**
	 * Return the named security if it exists. Otherwise return FALSE
	 * @param string $name
	 * @return boolean|SecurityScheme
	 */
	public function getSecurity($name)
	{
		if (isset($this->securityDefinitions[$name])) {
			return $this->securityDefinitions[$name];
		}

		return false;
	}

	/**
	 * @param string $command
	 * @param string $data
	 * @return \SwaggerGen\Swagger\AbstractObject|boolean
	 */
	public function handleCommand($command, $data = null)
	{
		switch (strtolower($command)) {
			// pass to Info
			case 'title':
			case 'description':
			case 'version':
			case 'terms': // alias
			case 'tos': // alias
			case 'termsofservice':
			case 'contact':
			case 'license':
				return $this->info->handleCommand($command, $data);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

			// string[]
			case 'scheme':
			case 'schemes':
				$this->schemes = array_unique(array_merge($this->schemes, self::wordSplit($data)));
				return $this;

			// MIME[]
			case 'consume':
			case 'consumes':
				$this->consumes = array_merge($this->consumes, self::translateMimeTypes(self::wordSplit($data)));
				return $this;

			case 'produce':
			case 'produces':

				$this->produces = array_merge($this->produces, self::translateMimeTypes(self::wordSplit($data)));
				return $this;

			case 'model':
			case 'definition':
				$definition = new Schema($this);
				$name = self::wordShift($data);
				if (empty($name)) {
					throw new \SwaggerGen\Exception('Missing definition name');
				}
				$this->definitions[$name] = $definition;
				return $definition;			

			case 'path':
			case 'query':
			case 'query?':
			case 'header':
			case 'header?':
			case 'form':
			case 'form?':

				$in = rtrim($command, '?');
				$Parameter = new Parameter($this, $in, $data, substr($command, -1) !== '?');
				$this->parameters[$Parameter->getName()] = $Parameter;
				return $Parameter;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

			case 'body':
			case 'body?':

				$Parameter = new BodyParameter($this, $data, substr($command, -1) !== '?');
				$this->parameters[$Parameter->getName()] = $Parameter;
				return $Parameter;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
				
			case 'response':

				$name = self::wordShift($data);
				$definition = self::wordShift($data);
				$description = $data;
				if (empty($description)) {
					throw new \SwaggerGen\Exception('Response definition missing description');
				}
				$Response = new Response($this, $name, $definition === 'null' ? null : $definition, $description);
				$this->responses[$name] = $Response;
				return $Response;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

			case 'api': // alias
			case 'tag':
				$tagname = self::wordShift($data);
				if (empty($tagname)) {
					throw new \SwaggerGen\Exception('Missing tag name');
				}

				$Tag = null;
				foreach ($this->tags as $T) {
					if ($T->getName() === $tagname) {
						$Tag = $T;
						break;
					}
				}
				if (!$Tag) {
					$Tag = new Tag($this, $tagname, $data);
					$this->tags[] = $Tag;
				}

				if ($command === 'api') { // backwards compatibility
					$this->defaultTag = $Tag;
				}
				return $Tag;

			case 'endpoint':
				$path = self::wordShift($data);
				if ($path{0} !== '/') {
					$path = '/' . $path;
				}

				$Tag = null;
				if (($tagname = self::wordShift($data)) !== false) {
					foreach ($this->tags as $T) {
						if (strtolower($T->getName()) === strtolower($tagname)) {
							$Tag = $T;
							break;
						}
					}
					if (!$Tag) {
						$Tag = new Tag($this, $tagname, $data);
						$this->tags[] = $Tag;
					}
				}

				if (!isset($this->paths[$path])) {
					$this->paths[$path] = new Path($this, $Tag ?: $this->defaultTag);
				}
				return $this->paths[$path];
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

			case 'security':

				$name = self::wordShift($data);
				if (empty($name)) {
					throw new \SwaggerGen\Exception('Missing security name');
				}
				$type = self::wordShift($data);
				if (empty($type)) {
					throw new \SwaggerGen\Exception('Missing security type');
				}
				$SecurityScheme = new SecurityScheme($this, $type, $data);
				$this->securityDefinitions[$name] = $SecurityScheme;
				return $SecurityScheme;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}

			case 'require':

				$name = self::wordShift($data);
				if (empty($name)) {
					throw new \SwaggerGen\Exception('Missing require name');
				}
				$scopes = self::wordSplit($data);
				sort($scopes);
				$this->security[] = array(
					$name => empty($scopes) ? array() : $scopes,
				);
				return $this;
		}

		return parent::handleCommand($command, $data);
	}

	/**
	 * @inheritDoc
	 */
	public function toArray()
	{
		if (empty($this->paths)) {
			throw new \SwaggerGen\Exception('No path defined');
		}

		$schemes = array_unique($this->schemes);
		sort($schemes);

		$consumes = array_unique($this->consumes);
		sort($consumes);

		$produces = array_unique($this->produces);
		sort($produces);

		foreach ($this->security as $security) {
			foreach ($security as $name => $scopes) {
				if (!isset($this->securityDefinitions[$name])) {
					throw new \SwaggerGen\Exception("Required security scheme not defined: '{$name}'");
				}
			}
		}

		return self::arrayFilterNull(array_merge(array(
					'swagger' => $this->swagger,
					'info' => $this->info->toArray(),
					'host' => empty($this->host) ? null : $this->host,
					'basePath' => empty($this->basePath) ? null : $this->basePath,
					'consumes' => $consumes,
					'produces' => $produces,
					'schemes' => $schemes,
					'paths' => self::objectsToArray($this->paths),
					'definitions' => self::objectsToArray($this->definitions),
					'parameters' => self::objectsToArray($this->parameters),
					'responses' => self::objectsToArray($this->responses),
					'securityDefinitions' => self::objectsToArray($this->securityDefinitions),
					'security' => $this->security,
					'tags' => self::objectsToArray($this->tags),
								), parent::toArray()));
	}

	public function __toString()
	{
		return __CLASS__;
	}

	/**
	 * Check if an operation with the given id exists.
	 * 
	 * @param string $operationId
	 * @return boolean
	 */
	public function hasOperationId($operationId)
	{
		foreach ($this->paths as $path) {
			if ($path->hasOperationId($operationId)) {
				return true;
			}
		}

		return false;
	}

}


vanderlee / PHPSwaggerGen