YamlConverter::visitType() - Code Metrics - Inspection of "scrutinizer enabled" - goetas-webservices/xsd2php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 55d992...2b96ce )

by Asmir

created 2016-09-26 06:44 UTC

YamlConverter::visitType() D

↳ Parent: YamlConverter

Complexity

Conditions	10
Paths	7

Size

Total Lines	41
Code Lines	24

Duplication

Lines	5
Ratio	12.2 %

Code Coverage

Tests	21
CRAP Score	10.7111

Importance

Changes

Metric	Value
dl	5
loc	41
ccs	21
cts	26
cp	0.8077
rs	4.8196
c	0
b	0
f	0
nc	7
cc	10
eloc	24
nop	2
crap	10.7111

How to fix Complexity

<?php
namespace GoetasWebservices\Xsd\XsdToPhp\Jms;

use Doctrine\Common\Inflector\Inflector;
use Exception;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeContainer;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeItem;
use GoetasWebservices\XML\XSDReader\Schema\Element\Element;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementContainer;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementDef;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementItem;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementRef;
use GoetasWebservices\XML\XSDReader\Schema\Item;
use GoetasWebservices\XML\XSDReader\Schema\Schema;
use GoetasWebservices\XML\XSDReader\Schema\SchemaItem;
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;
use GoetasWebservices\Xsd\XsdToPhp\AbstractConverter;
use GoetasWebservices\Xsd\XsdToPhp\Naming\NamingStrategy;

class YamlConverter extends AbstractConverter
{

    public function __construct(NamingStrategy $namingStrategy)
    {

        parent::__construct($namingStrategy);

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

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

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

            return "DateTime<'Y-m-d'>";
        });
    }

    private $classes = [];

    public function convert(array $schemas)

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

    private function flattAttributes(AttributeContainer $container)
    {
        $items = array();
        foreach ($container->getAttributes() as $attr) {
            if ($attr instanceof AttributeContainer) {
                $items = array_merge($items, $this->flattAttributes($attr));
            } else {
                $items[] = $attr;
            }
        }
        return $items;
    }

    private function flattElements(ElementContainer $container)
    {
        $items = array();
        foreach ($container->getElements() as $attr) {
            if ($attr instanceof ElementContainer) {
                $items = array_merge($items, $this->flattElements($attr));
            } else {
                $items[] = $attr;
            }
        }
        return $items;
    }

    /**
     *
     * @return PHPClass[]
     */
    public function getTypes()
    {
        uasort($this->classes, function ($a, $b) {
            return strcmp(key($a), key($b));
        });

        $ret = array();

        foreach ($this->classes as $definition) {
            $classname = key($definition["class"]);
            if (strpos($classname, '\\') !== false && (!isset($definition["skip"]) || !$definition["skip"])) {
                $ret[$classname] = $definition["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($schema, $element);
        }

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

    private function visitTypeBase(&$class, &$data, Type $type, $name)
    {
        if ($type instanceof BaseComplexType) {
            $this->visitBaseComplexType($class, $data, $type, $name);
        }
        if ($type instanceof ComplexType) {
            $this->visitComplexType($class, $data, $type);
        }
        if ($type instanceof SimpleType) {
            $this->visitSimpleType($class, $data, $type, $name);
        }
    }

    public function &visitElementDef(Schema $schema, ElementDef $element)
    {
        if (!isset($this->classes[spl_object_hash($element)])) {
            $className = $this->findPHPNamespace($element) . "\\" . $this->getNamingStrategy()->getItemName($element);
            $class = array();
            $data = array();
            $ns = $className;
            $class[$ns] = &$data;
            $data["xml_root_name"] = $element->getName();

            if ($schema->getTargetNamespace()) {
                $data["xml_root_namespace"] = $schema->getTargetNamespace();
            }
            $this->classes[spl_object_hash($element)]["class"] = &$class;

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

    private function findPHPNamespace(SchemaItem $item)
    {
        $schema = $item->getSchema();

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

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


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

        if ($alias = $this->getTypeAlias($type, $schema)) {
            return $alias;
        }

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

        return $ns . "\\" . $name;
    }


    public function &visitType(Type $type, $force = false)
    {

        if (!isset($this->classes[spl_object_hash($type)])) {

            if ($alias = $this->getTypeAlias($type)) {
                $class = array();
                $class[$alias] = array();

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

            $className = $this->findPHPName($type);

            $class = array();
            $data = array();

            $class[$className] = &$data;

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

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

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

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

    private function &visitTypeAnonymous(Type $type, $parentName, $parentClass)
    {
        $class = array();
        $data = array();

        $name = $this->getNamingStrategy()->getAnonymousTypeName($type, $parentName);

        $class[key($parentClass) . "\\" . $name] = &$data;

        $this->visitTypeBase($class, $data, $type, $parentName);
        if ($parentName) {
            $this->classes[spl_object_hash($type)]["class"] = &$class;

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

    private function visitComplexType(&$class, &$data, ComplexType $type)
    {
        $schema = $type->getSchema();
        if (!isset($data["properties"])) {
            $data["properties"] = array();
        }
        foreach ($this->flattElements($type) as $element) {
            $data["properties"][$this->getNamingStrategy()->getPropertyName($element)] = $this->visitElement($class, $schema, $element);
        }
    }

    private function visitSimpleType(&$class, &$data, SimpleType $type, $name)
    {
        if ($restriction = $type->getRestriction()) {
            $parent = $restriction->getBase();
            if ($parent instanceof Type) {
                $this->handleClassExtension($class, $data, $parent, $name);
            }
        } elseif ($unions = $type->getUnions()) {
            foreach ($unions as $i => $unon) {
                $this->handleClassExtension($class, $data, $unon, $name . $i);
                break;
            }
        }
    }

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

        $schema = $type->getSchema();
        if (!isset($data["properties"])) {
            $data["properties"] = array();
        }
        foreach ($this->flattAttributes($type) as $attr) {
            $data["properties"][$this->getNamingStrategy()->getPropertyName($attr)] = $this->visitAttribute($class, $schema, $attr);
        }
    }

    private function handleClassExtension(&$class, &$data, Type $type, $parentName)
    {
        if ($alias = $this->getTypeAlias($type)) {


            $property = array();
            $property["expose"] = true;
            $property["xml_value"] = true;
            $property["access_type"] = "public_method";
            $property["accessor"]["getter"] = "value";
            $property["accessor"]["setter"] = "value";
            $property["type"] = $alias;

            $data["properties"]["__value"] = $property;


        } else {
            $extension = $this->visitType($type, true);

            if (isset($extension['properties']['__value']) && count($extension['properties']) === 1) {
                $data["properties"]["__value"] = $extension['properties']['__value'];
            } else {
                if ($type instanceof SimpleType) { // @todo ?? basta come controllo?
                    $property = array();
                    $property["expose"] = true;
                    $property["xml_value"] = true;
                    $property["access_type"] = "public_method";
                    $property["accessor"]["getter"] = "value";
                    $property["accessor"]["setter"] = "value";

                    if ($valueProp = $this->typeHasValue($type, $class, $parentName)) {
                        $property["type"] = $valueProp;
                    } else {
                        $property["type"] = key($extension);
                    }

                    $data["properties"]["__value"] = $property;

                }
            }
        }
    }

    private function visitAttribute(&$class, Schema $schema, AttributeItem $attribute)
    {
        $property = array();
        $property["expose"] = true;
        $property["access_type"] = "public_method";
        $property["serialized_name"] = $attribute->getName();

        $property["accessor"]["getter"] = "get" . Inflector::classify($attribute->getName());
        $property["accessor"]["setter"] = "set" . Inflector::classify($attribute->getName());

        $property["xml_attribute"] = true;

        if ($alias = $this->getTypeAlias($attribute)) {
            $property["type"] = $alias;

        } elseif ($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 ($valueProp = $this->typeHasValue($itemOfArray, $class, 'xx')) {

                $property["type"] = "GoetasWebservices\Xsd\XsdToPhp\Jms\SimpleListOf<" . $valueProp . ">";
            } else {
                $property["type"] = "GoetasWebservices\Xsd\XsdToPhp\Jms\SimpleListOf<" . $this->findPHPName($itemOfArray) . ">";
            }

            $property["xml_list"]["inline"] = false;
            $property["xml_list"]["entry_name"] = $itemOfArray->getName();
            if ($schema->getTargetNamespace()) {
                $property["xml_list"]["entry_namespace"] = $schema->getTargetNamespace();
            }
        } else {
            $property["type"] = $this->findPHPClass($class, $attribute);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    private function typeHasValue(Type $type, $parentClass, $name)
    {
        $collected = array();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
        do {
            if ($alias = $this->getTypeAlias($type)) {
                return $alias;
            } else {

                if ($type->getName()) {
                    $parentClass = $this->visitType($type);
                } else {
                    $parentClass = $this->visitTypeAnonymous($type, $name, $parentClass);
                }
                $props = reset($parentClass);
                if (isset($props['properties']['__value']) && count($props['properties']) === 1) {
                    return $props['properties']['__value']['type'];
                }
            }
        } while (method_exists($type, 'getRestriction') && $type->getRestriction() && $type = $type->getRestriction()->getBase());

        return false;
    }

    /**
     *
     * @param PHPClass $class
     * @param Schema $schema
     * @param Element $element
     * @param boolean $arrayize
     * @return \GoetasWebservices\Xsd\XsdToPhp\Structure\PHPProperty
     */
    private function visitElement(&$class, Schema $schema, ElementItem $element, $arrayize = true)
    {
        $property = array();
        $property["expose"] = true;
        $property["access_type"] = "public_method";
        $property["serialized_name"] = $element->getName();

        if ($schema->getTargetNamespace() && ($schema->getElementsQualification() || ($element instanceof Element && $element->isQualified()))) {
            $property["xml_element"]["namespace"] = $schema->getTargetNamespace();
        }

        $property["accessor"]["getter"] = "get" . Inflector::classify($element->getName());
        $property["accessor"]["setter"] = "set" . Inflector::classify($element->getName());
        $t = $element->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 ($arrayize) {

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

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

                $visited = $this->visitElement($classType, $schema, $itemOfArray, false);

                $property["type"] = "array<" . $visited["type"] . ">";
                $property["xml_list"]["inline"] = false;
                $property["xml_list"]["entry_name"] = $itemOfArray->getName();
                if ($schema->getTargetNamespace()) {
                    $property["xml_list"]["namespace"] = $schema->getTargetNamespace();
                }
                return $property;
            } elseif ($itemOfArray = $this->isArrayType($t)) {

                if (!$t->getName()) {
                    $visitedType = $this->visitTypeAnonymous($itemOfArray, $element->getName(), $class);

                    if ($prop = $this->typeHasValue($itemOfArray, $class, 'xx')) {

                        $property["type"] = "array<" . $prop . ">";
                    } else {
                        $property["type"] = "array<" . key($visitedType) . ">";
                    }
                } else {
                    $this->visitType($itemOfArray);
                    $property["type"] = "array<" . $this->findPHPName($itemOfArray) . ">";
                }

                $property["xml_list"]["inline"] = false;
                $property["xml_list"]["entry_name"] = $itemOfArray->getName();
                if ($schema->getTargetNamespace()) {
                    $property["xml_list"]["namespace"] = $schema->getTargetNamespace();
                }
                return $property;
            } elseif ($this->isArrayElement($element)) {
                $property["xml_list"]["inline"] = true;
                $property["xml_list"]["entry_name"] = $element->getName();
                if ($schema->getTargetNamespace()) {
                    $property["xml_list"]["namespace"] = $schema->getTargetNamespace();
                }

                $property["type"] = "array<" . $this->findPHPClass($class, $element) . ">";
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

        $property["type"] = $this->findPHPClass($class, $element);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

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

    private function findPHPClass(&$class, Item $node)
    {
        $type = $node->getType();

        if ($alias = $this->getTypeAlias($node->getType())) {
            return $alias;
        }
        if ($node instanceof ElementRef) {
            $elementRef = $this->visitElementDef($node->getSchema(), $node->getReferencedElement());
            return key($elementRef);
        }
        if ($valueProp = $this->typeHasValue($type, $class, '')) {
            return $valueProp;
        }
        if (!$node->getType()->getName()) {

            $visited = $this->visitTypeAnonymous($node->getType(), $node->getName(), $class);
        } else {
            $visited = $this->visitType($node->getType());
        }

        return key($visited);
    }
}


Push — master ( 55d992...2b96ce )

YamlConverter::visitType() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

1		<?php
2		namespace GoetasWebservices\Xsd\XsdToPhp\Jms;
3
4		use Doctrine\Common\Inflector\Inflector;
5		use Exception;
6		use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeContainer;
7		use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeItem;
8		use GoetasWebservices\XML\XSDReader\Schema\Element\Element;
9		use GoetasWebservices\XML\XSDReader\Schema\Element\ElementContainer;
10		use GoetasWebservices\XML\XSDReader\Schema\Element\ElementDef;
11		use GoetasWebservices\XML\XSDReader\Schema\Element\ElementItem;
12		use GoetasWebservices\XML\XSDReader\Schema\Element\ElementRef;
13		use GoetasWebservices\XML\XSDReader\Schema\Item;
14		use GoetasWebservices\XML\XSDReader\Schema\Schema;
15		use GoetasWebservices\XML\XSDReader\Schema\SchemaItem;
16		use GoetasWebservices\XML\XSDReader\Schema\Type\BaseComplexType;
17		use GoetasWebservices\XML\XSDReader\Schema\Type\ComplexType;
18		use GoetasWebservices\XML\XSDReader\Schema\Type\SimpleType;
19		use GoetasWebservices\XML\XSDReader\Schema\Type\Type;
20		use GoetasWebservices\Xsd\XsdToPhp\AbstractConverter;
21		use GoetasWebservices\Xsd\XsdToPhp\Naming\NamingStrategy;
22
23		class YamlConverter extends AbstractConverter
24		{
25
26	22	public function __construct(NamingStrategy $namingStrategy)
27		{
28
29	22	parent::__construct($namingStrategy);
30
31		$this->addAliasMap('http://www.w3.org/2001/XMLSchema', 'dateTime', function (Type $type) {
		0 ignored issues – show Unused Code introduced 2016-09-26 07:16 UTC by Report Bug Copy Issue Report The parameter `$type` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
32	3	return "GoetasWebservices\Xsd\XsdToPhp\XMLSchema\DateTime";
33	22	});
34		$this->addAliasMap('http://www.w3.org/2001/XMLSchema', 'time', function (Type $type) {
		0 ignored issues – show Unused Code introduced 2016-09-26 07:16 UTC by Report Bug Copy Issue Report The parameter `$type` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
35		return "GoetasWebservices\Xsd\XsdToPhp\XMLSchema\Time";
36	22	});
37		$this->addAliasMap("http://www.w3.org/2001/XMLSchema", "date", function (Type $type) {
		0 ignored issues – show Unused Code introduced 2016-09-26 07:16 UTC by Report Bug Copy Issue Report The parameter `$type` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...

goetas-webservices / xsd2php

Push — master ( 55d992...2b96ce )

YamlConverter::visitType() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like