PhpConverter - Code Metrics - Inspection of "Allow xsd:enumeration" - goetas/xsd2php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#121)

unknown

created 2017-01-26 05:50 UTC

PhpConverter F

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	511
Duplicated Lines	19.96 %

Coupling/Cohesion

Components	1
Dependencies	20

Test Coverage

Coverage

89.16%

Importance

Changes

Metric	Value
wmc	86
lcom	1
cbo	20
dl	102
loc	511
ccs	255
cts	286
cp	0.8916
rs	1.5789
c	0
b	0
f	0

19 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	20	1
A	convert()	9	9	2
A	getTypes()	0	14	4
B	navigate()	20	20	6
A	visitTypeBase()	0	14	4
A	visitGroup()	11	11	3
A	visitAttributeGroup()	8	11	3
B	visitElementDef()	3	25	4
B	findPHPName()	3	30	4
A	visitTypeAnonymous()	0	17	3
A	visitComplexType()	12	12	3
D	visitSimpleType()	0	36	10
A	handleClassExtension()	0	14	2
B	visitBaseComplexType()	8	20	5
A	visitAttribute()	0	20	4
C	visitElement()	10	41	7
A	findPHPClass()	5	13	3
C	visitType()	13	41	13
B	createConstantNameFromValue()	0	90	5

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 PhpConverter 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 PhpConverter, and based on these observations, apply Extract Interface, too.

<?php
namespace Goetas\Xsd\XsdToPhp\Php;

use Cocur\Slugify\Slugify;
use Doctrine\Common\Inflector\Inflector;
use Exception;
use Goetas\Xsd\XsdToPhp\AbstractConverter;
use Goetas\Xsd\XsdToPhp\Naming\NamingStrategy;
use Goetas\Xsd\XsdToPhp\Php\Structure\PHPArg;
use Goetas\Xsd\XsdToPhp\Php\Structure\PHPClass;
use Goetas\Xsd\XsdToPhp\Php\Structure\PHPClassOf;
use Goetas\Xsd\XsdToPhp\Php\Structure\PHPProperty;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeItem;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\Group as AttributeGroup;
use GoetasWebservices\XML\XSDReader\Schema\Element\Element;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementDef;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementRef;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementSingle;
use GoetasWebservices\XML\XSDReader\Schema\Element\Group;
use GoetasWebservices\XML\XSDReader\Schema\Item;
use GoetasWebservices\XML\XSDReader\Schema\Schema;
use GoetasWebservices\XML\XSDReader\Schema\Type\BaseComplexType;
use GoetasWebservices\XML\XSDReader\Schema\Type\ComplexType;
use GoetasWebservices\XML\XSDReader\Schema\Type\SimpleType;
use GoetasWebservices\XML\XSDReader\Schema\Type\Type;

class PhpConverter extends AbstractConverter
{

    public function __construct(NamingStrategy $namingStrategy)
    {
        parent::__construct($namingStrategy);

        $this->addAliasMap("http://www.w3.org/2001/XMLSchema", "dateTime", function (Type $type) {

            return "DateTime";
        });
        $this->addAliasMap("http://www.w3.org/2001/XMLSchema", "time", function (Type $type) {

            return "DateTime";
        });
        $this->addAliasMap("http://www.w3.org/2001/XMLSchema", "date", function (Type $type) {

            return "DateTime";
        });
        $this->addAliasMap("http://www.w3.org/2001/XMLSchema", "anySimpleType", function (Type $type) {

            return "mixed";
        });
        $this->addAliasMap("http://www.w3.org/2001/XMLSchema", "anyType", function (Type $type) {

            return "mixed";
        });
    }

    private $classes = [];

    public function convert(array $schemas)

    {
        $visited = array();
        $this->classes = array();
        foreach ($schemas as $schema) {
            $this->navigate($schema, $visited);
        }
        return $this->getTypes();
    }

    /**
     *
     * @return PHPClass[]
     */
    private function getTypes()
    {
        uasort($this->classes, function ($a, $b) {
            return strcmp($a["class"]->getFullName(), $b["class"]->getFullName());
        });
        $ret = array();
        foreach ($this->classes as $classData) {
            if (!isset($classData["skip"]) || !$classData["skip"]) {
                $ret[$classData["class"]->getFullName()] = $classData["class"];
            }
        }

        return $ret;
    }

    private function navigate(Schema $schema, array &$visited)

    {
        if (isset($visited[spl_object_hash($schema)])) {
            return;
        }
        $visited[spl_object_hash($schema)] = true;

        foreach ($schema->getTypes() as $type) {
            $this->visitType($type);
        }
        foreach ($schema->getElements() as $element) {
            $this->visitElementDef($element);
        }

        foreach ($schema->getSchemas() as $schildSchema) {
            if (!in_array($schildSchema->getTargetNamespace(), $this->baseSchemas, true)) {
                $this->navigate($schildSchema, $visited);
            }
        }
    }

    private function visitTypeBase(PHPClass $class, Type $type)
    {
        $class->setAbstract($type->isAbstract());

        if ($type instanceof SimpleType) {
            $this->visitSimpleType($class, $type);
        }
        if ($type instanceof BaseComplexType) {
            $this->visitBaseComplexType($class, $type);
        }
        if ($type instanceof ComplexType) {
            $this->visitComplexType($class, $type);
        }
    }

    private function visitGroup(PHPClass $class, Schema $schema, Group $group)

    {
        foreach ($group->getElements() as $childGroup) {
            if ($childGroup instanceof Group) {
                $this->visitGroup($class, $schema, $childGroup);
            } else {
                $property = $this->visitElement($class, $schema, $childGroup);
                $class->addProperty($property);
            }
        }
    }

    private function visitAttributeGroup(PHPClass $class, Schema $schema, AttributeGroup $att)
    {
        foreach ($att->getAttributes() as $childAttr) {

            if ($childAttr instanceof AttributeGroup) {
                $this->visitAttributeGroup($class, $schema, $childAttr);
            } else {
                $property = $this->visitAttribute($class, $schema, $childAttr);
                $class->addProperty($property);
            }
        }
    }

    private function visitElementDef(ElementDef $element)
    {
        if (!isset($this->classes[spl_object_hash($element)])) {
            $schema = $element->getSchema();

            $class = new PHPClass();
            $class->setDoc($element->getDoc());
            $class->setName($this->getNamingStrategy()->getItemName($element));
            $class->setDoc($element->getDoc());

            if (!isset($this->namespaces[$schema->getTargetNamespace()])) {

                throw new Exception(sprintf("Can't find a PHP namespace to '%s' namespace", $schema->getTargetNamespace()));
            }
            $class->setNamespace($this->namespaces[$schema->getTargetNamespace()]);

            $this->classes[spl_object_hash($element)]["class"] = $class;

            if (!$element->getType()->getName()) {
                $this->visitTypeBase($class, $element->getType());
            } else {
                $this->handleClassExtension($class, $element->getType());
            }
        }
        return $this->classes[spl_object_hash($element)]["class"];
    }

    private function findPHPName(Type $type)
    {
        $schema = $type->getSchema();

        if ($className = $this->getTypeAlias($type)) {

            if (($pos = strrpos($className, '\\')) !== false) {
                return [
                    substr($className, $pos + 1),
                    substr($className, 0, $pos)
                ];
            } else {
                return [
                    $className,
                    null
                ];
            }
        }

        $name = $this->getNamingStrategy()->getTypeName($type);

        if (!isset($this->namespaces[$schema->getTargetNamespace()])) {

            throw new Exception(sprintf("Can't find a PHP namespace to '%s' namespace", $schema->getTargetNamespace()));
        }
        $ns = $this->namespaces[$schema->getTargetNamespace()];
        return [
            $name,
            $ns
        ];
    }

    /**
     *
     * @param Type $type
     * @param boolean $force
     * @return \Goetas\Xsd\XsdToPhp\Php\Structure\PHPClass
     */
    private function visitType(Type $type, $force = false)
    {
        if (!isset($this->classes[spl_object_hash($type)])) {

            $this->classes[spl_object_hash($type)]["class"] = $class = new PHPClass();

            if ($alias = $this->getTypeAlias($type)) {
                $class->setName($alias);
                $this->classes[spl_object_hash($type)]["skip"] = true;
                return $class;
            }

            list ($name, $ns) = $this->findPHPName($type);
            $class->setName($name);
            $class->setNamespace($ns);

            $class->setDoc($type->getDoc() . PHP_EOL . "XSD Type: " . ($type->getName() ?: 'anonymous'));

            $this->visitTypeBase($class, $type);

            if ( ( $restriction = $type->getRestriction() ) && $restriction->getChecksByType( 'enumeration' ) ) {
                return $class;
            }

            if ($type instanceof SimpleType) {

                $this->classes[spl_object_hash($type)]["skip"] = true;
                return $class;
            }
            if (($this->isArrayType($type) || $this->isArrayNestedElement($type)) && !$force) {

                $this->classes[spl_object_hash($type)]["skip"] = true;
                return $class;
            }

            $this->classes[spl_object_hash($type)]["skip"] = !!$this->getTypeAlias($type);
        } elseif ($force) {

            if (!($type instanceof SimpleType) && !$this->getTypeAlias($type)) {
                $this->classes[spl_object_hash($type)]["skip"] = false;
            }
        }
        return $this->classes[spl_object_hash($type)]["class"];
    }

    /**
     * @param Type $type
     * @param string $name
     * @param PHPClass $parentClass
     * @return \Goetas\Xsd\XsdToPhp\Php\Structure\PHPClass
     */
    private function visitTypeAnonymous(Type $type, $name, PHPClass $parentClass)
    {
        if (!isset($this->classes[spl_object_hash($type)])) {
            $this->classes[spl_object_hash($type)]["class"] = $class = new PHPClass();
            $class->setName($this->getNamingStrategy()->getAnonymousTypeName($type, $name));

            $class->setNamespace($parentClass->getNamespace() . "\\" . $parentClass->getName());
            $class->setDoc($type->getDoc());

            $this->visitTypeBase($class, $type);

            if ($type instanceof SimpleType) {
                $this->classes[spl_object_hash($type)]["skip"] = true;
            }
        }
        return $this->classes[spl_object_hash($type)]["class"];
    }

    private function visitComplexType(PHPClass $class, ComplexType $type)

    {
        $schema = $type->getSchema();
        foreach ($type->getElements() as $element) {
            if ($element instanceof Group) {
                $this->visitGroup($class, $schema, $element);
            } else {
                $property = $this->visitElement($class, $schema, $element);
                $class->addProperty($property);
            }
        }
    }

    private function visitSimpleType(PHPClass $class, SimpleType $type)
    {
        if ($restriction = $type->getRestriction()) {
            $parent = $restriction->getBase();

            if ($parent instanceof Type) {
                $this->handleClassExtension($class, $parent);
            }

            foreach ($restriction->getChecks() as $typeCheck => $checks) {
                foreach ($checks as $check) {
                    if ( $typeCheck === 'enumeration' ) {
                        $class->addConstant(
                            $this->createConstantNameFromValue( $check[ 'value' ] ),
                            $check[ 'value' ]
                        );
                    } else {
                        $class->addCheck( '__value', $typeCheck, $check );
                    }
                }
            }
        } elseif ($unions = $type->getUnions()) {
            $types = array();
            foreach ($unions as $i => $unon) {
                if (!$unon->getName()) {
                    $types[] = $this->visitTypeAnonymous($unon, $type->getName() . $i, $class);
                } else {
                    $types[] = $this->visitType($unon);
                }
            }

            if ($candidato = reset($types)) {
                $class->setExtends($candidato);
            }
        }
    }

    private function handleClassExtension(PHPClass $class, Type $type)
    {

        if ($alias = $this->getTypeAlias($type)) {
            $c = PHPClass::createFromFQCN($alias);
            $val = new PHPProperty('__value');
            $val->setType($c);
            $c->addProperty($val);
            $class->setExtends($c);
        } else {
            $extension = $this->visitType($type, true);
            $class->setExtends($extension);
        }
    }

    private function visitBaseComplexType(PHPClass $class, BaseComplexType $type)
    {
        $parent = $type->getParent();
        if ($parent) {
            $parentType = $parent->getBase();
            if ($parentType instanceof Type) {
                $this->handleClassExtension($class, $parentType);
            }
        }
        $schema = $type->getSchema();

        foreach ($type->getAttributes() as $attr) {

            if ($attr instanceof AttributeGroup) {
                $this->visitAttributeGroup($class, $schema, $attr);
            } else {
                $property = $this->visitAttribute($class, $schema, $attr);
                $class->addProperty($property);
            }
        }
    }

    private function visitAttribute(PHPClass $class, Schema $schema, AttributeItem $attribute, $arrayize = true)

    {
        $property = new PHPProperty();
        $property->setName($this->getNamingStrategy()->getPropertyName($attribute));

        if ($arrayize && $itemOfArray = $this->isArrayType($attribute->getType())) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            if ($attribute->getType()->getName()) {
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                $arg = new PHPArg($this->getNamingStrategy()->getPropertyName($attribute));
                $arg->setType($this->visitType($itemOfArray));
                $property->setType(new PHPClassOf($arg));
            } else {
                $property->setType($this->visitTypeAnonymous($attribute->getType(), $attribute->getName(), $class));
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            }
        } else {
            $property->setType($this->findPHPClass($class, $attribute, true));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        }

        $property->setDoc($attribute->getDoc());
        return $property;
    }

    /**
     *
     * @param PHPClass $class
     * @param Schema $schema
     * @param Element $element
     * @param boolean $arrayize
     * @return \Goetas\Xsd\XsdToPhp\Structure\PHPProperty
     */
    private function visitElement(PHPClass $class, Schema $schema, ElementSingle $element, $arrayize = true)
    {
        $property = new PHPProperty();
        $property->setName($this->getNamingStrategy()->getPropertyName($element));
        $property->setDoc($element->getDoc());

        $t = $element->getType();

        if ($arrayize) {
            if ($itemOfArray = $this->isArrayType($t)) {
                if (!$itemOfArray->getName()) {

                    $classType = $this->visitTypeAnonymous($itemOfArray, $element->getName(), $class);
                } else {
                    $classType = $this->visitType($itemOfArray);
                }

                $arg = new PHPArg($this->getNamingStrategy()->getPropertyName($element));
                $arg->setType($classType);
                $property->setType(new PHPClassOf($arg));
                return $property;
            } elseif ($itemOfArray = $this->isArrayNestedElement($t)) {
                if (!$t->getName()) {

                    $classType = $this->visitTypeAnonymous($t, $element->getName(), $class);
                } else {
                    $classType = $this->visitType($t);
                }
                $elementProp = $this->visitElement($classType, $schema, $itemOfArray, false);
                $property->setType(new PHPClassOf($elementProp));
                return $property;
            } elseif ($this->isArrayElement($element)) {
                $arg = new PHPArg($this->getNamingStrategy()->getPropertyName($element));
                $arg->setType($this->findPHPClass($class, $element));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                $arg->setDefault('array()');
                $property->setType(new PHPClassOf($arg));
                return $property;
            }
        }

        $property->setType($this->findPHPClass($class, $element, true));
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        return $property;
    }

    private function findPHPClass(PHPClass $class, Item $node, $force = false)
    {

        if ($node instanceof ElementRef) {
            return $this->visitElementDef($node->getReferencedElement());
        }

        if (!$node->getType()->getName()) {

            return $this->visitTypeAnonymous($node->getType(), $node->getName(), $class);
        } else {
            return $this->visitType($node->getType(), $force);
        }
    }
	/**
	 * @param $constantValue
	 *
	 * @return string
	 */
	public function createConstantNameFromValue( $constantValue ) {
		static $keywords = [
			'abstract',
			'and',
			'array',
			'as',
			'break',
			'callable',
			'case',
			'catch',
			'class',
			'clone',
			'const',
			'continue',
			'declare',
			'default',
			'die',
			'do',
			'echo',
			'else',
			'elseif',
			'empty',
			'enddeclare',
			'endfor',
			'endforeach',
			'endif',
			'endswitch',
			'endwhile',
			'eval',
			'exit',
			'extends',
			'final',
			'for',
			'foreach',
			'function',
			'global',
			'goto',
			'if',
			'implements',
			'include',
			'include_once',
			'instanceof',
			'insteadof',
			'interface',
			'isset',
			'list',
			'namespace',
			'new',
			'or',
			'print',
			'private',
			'protected',
			'public',
			'require',
			'require_once',
			'return',
			'static',
			'switch',
			'throw',
			'trait',
			'try',
			'unset',
			'use',
			'var',
			'while',
			'xor',
		];

		$slugify      = new Slugify();
		$constantName = $slugify->slugify( $constantValue, '_' );
		if ( in_array( $constantName, $keywords ) ) {
			$constantName = $constantName . '_';
		}

        if (is_numeric($constantName)) {
            $constantName = 'NUM_' . $constantName;
        }

        if (is_numeric(substr($constantName, 0, 1))) {
            $constantName = '_' . $constantName;
        }

        if ($constantName === '') {
            $constantName = 'EMPTY_STRING';
        }

		$constantName = strtoupper( $constantName );

		return $constantName;
	}

}


Pull Request — master (#121)

PhpConverter F

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

19 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

goetas / xsd2php

Pull Request — master (#121)

PhpConverter F

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

19 Methods

How to fix Duplicated Code Complexity

Duplicated Code

Complex Class

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like