AbstractSchemaReader::fillItem() - Code Metrics - Inspection of "Static analysis" - goetas-webservices/xsd-reader - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#18)

by SignpostMarv

created 2017-10-20 22:01 UTC

AbstractSchemaReader::fillItem() B

↳ Parent: AbstractSchemaReader

Complexity

Conditions	3
Paths	3

Size

Total Lines	25
Code Lines	14

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	3
eloc	14
c	0
b	0
f	0
nc	3
nop	2
dl	0
loc	25
rs	8.8571

<?php
namespace GoetasWebservices\XML\XSDReader;

use Closure;
use DOMDocument;
use DOMElement;
use DOMNode;
use DOMNodeList;
use GoetasWebservices\XML\XSDReader\Exception\IOException;
use GoetasWebservices\XML\XSDReader\Exception\TypeException;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\Attribute;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeDef;
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\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\Element\Group;
use GoetasWebservices\XML\XSDReader\Schema\Element\GroupRef;
use GoetasWebservices\XML\XSDReader\Schema\Element\InterfaceSetMinMax;
use GoetasWebservices\XML\XSDReader\Schema\Exception\TypeNotFoundException;
use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Base;
use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Extension;
use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Restriction;
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\ComplexTypeSimpleContent;
use GoetasWebservices\XML\XSDReader\Schema\Type\SimpleType;
use GoetasWebservices\XML\XSDReader\Schema\Type\Type;
use GoetasWebservices\XML\XSDReader\Utils\UrlUtils;
use RuntimeException;

abstract class AbstractSchemaReader
{

    const XSD_NS = "http://www.w3.org/2001/XMLSchema";

    const XML_NS = "http://www.w3.org/XML/1998/namespace";

    /**
    * @var string[]
    */
    protected $knownLocationSchemas = [
        'http://www.w3.org/2001/xml.xsd' => (
            __DIR__ . '/Resources/xml.xsd'
        ),
        'http://www.w3.org/2001/XMLSchema.xsd' => (
            __DIR__ . '/Resources/XMLSchema.xsd'
        ),
        'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd' => (
            __DIR__ . '/Resources/oasis-200401-wss-wssecurity-secext-1.0.xsd'
        ),
        'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd' => (
            __DIR__ . '/Resources/oasis-200401-wss-wssecurity-utility-1.0.xsd'
        ),
        'https://www.w3.org/TR/xmldsig-core/xmldsig-core-schema.xsd' => (
            __DIR__ . '/Resources/xmldsig-core-schema.xsd'
        ),
        'http://www.w3.org/TR/xmldsig-core/xmldsig-core-schema.xsd' => (
            __DIR__ . '/Resources/xmldsig-core-schema.xsd'
        ),
    ];

    /**
    * @var string[]
    */
    protected static $globalSchemaInfo = array(
        self::XML_NS => 'http://www.w3.org/2001/xml.xsd',
        self::XSD_NS => 'http://www.w3.org/2001/XMLSchema.xsd'
    );

    /**
    * @param string $remote
    * @param string $local
    */
    public function addKnownSchemaLocation($remote, $local)
    {
        $this->knownLocationSchemas[$remote] = $local;
    }

    /**
    * @param string $remote
    *
    * @return bool
    */
    public function hasKnownSchemaLocation($remote)
    {
        return isset($this->knownLocationSchemas[$remote]);
    }

    /**
    * @param string $remote
    *
    * @return string
    */
    public function getKnownSchemaLocation($remote)
    {
        return $this->knownLocationSchemas[$remote];
    }

    /**
    * @return Closure
    */
    abstract protected function loadAttributeGroup(Schema $schema, DOMElement $node);

    /**
    * @param bool $attributeDef
    *
    * @return Closure
    */
    abstract protected function loadAttributeOrElementDef(
        Schema $schema,
        DOMElement $node,
        $attributeDef
    );

    /**
    * @return Closure
    */
    abstract protected function loadAttributeDef(Schema $schema, DOMElement $node);

    /**
     * @param DOMElement $node
     * @return string
     */
    public static function getDocumentation(DOMElement $node)
    {
        $doc = '';
        foreach ($node->childNodes as $childNode) {
            if ($childNode->localName == "annotation") {
                $doc .= static::getDocumentation($childNode);
            } elseif ($childNode->localName == 'documentation') {
                $doc .= ($childNode->nodeValue);
            }
        }
        $doc = preg_replace('/[\t ]+/', ' ', $doc);
        return trim($doc);
    }

    /**
    * @param string $key
    *
    * @return Closure|null
    */
    public function maybeCallMethod(
        array $methods,
        $key,
        DOMNode $childNode,
        ...$args
    ) {
        if ($childNode instanceof DOMElement && isset($methods[$key])) {
            $method = $methods[$key];

            $append = $this->$method(...$args);

            if ($append instanceof Closure) {
                return $append;
            }
        }
    }

    /**
     *
     * @param Schema $schema
     * @param DOMElement $node
     * @param Schema $parent
     * @return Closure[]
     */
    public function schemaNode(Schema $schema, DOMElement $node, Schema $parent = null)
    {
        $schema->setSchemaThingsFromNode($node, $parent);
        $functions = array();

        $schemaReaderMethods = [
            'include' => (Schema::class . '::loadImport'),
            'import' => (Schema::class . '::loadImport'),
        ];

        $thisMethods = [
            'element' => [$this, 'loadElementDef'],
            'attribute' => [$this, 'loadAttributeDef'],
            'attributeGroup' => [$this, 'loadAttributeGroup'],
            'group' => [$this, 'loadGroup'],
            'complexType' => [$this, 'loadComplexType'],
            'simpleType' => [$this, 'loadSimpleType'],
        ];

        foreach ($node->childNodes as $childNode) {
            if ($childNode instanceof DOMElement) {
                $callback = $this->maybeCallCallableWithArgs(
                    $childNode,
                        [],
                        [],
                        [
                            [
                                $schemaReaderMethods,
                                [
                                    $this,
                                    $schema,
                                    $childNode,
                                ]
                            ],
                            [
                                $thisMethods,
                                [
                                    $schema,
                                    $childNode
                                ],
                            ],
                        ]
                );

                if ($callback instanceof Closure) {
                    $functions[] = $callback;
                }
            }
        }

        return $functions;
    }

    /**
    * @return InterfaceSetMinMax
    */
    public static function maybeSetMax(InterfaceSetMinMax $ref, DOMElement $node)
    {
        if (
            $node->hasAttribute("maxOccurs")
        ) {
            $ref->setMax($node->getAttribute("maxOccurs") == "unbounded" ? -1 : (int)$node->getAttribute("maxOccurs"));
        }

        return $ref;
    }

    /**
    * @return InterfaceSetMinMax
    */
    public static function maybeSetMin(InterfaceSetMinMax $ref, DOMElement $node)
    {
        if ($node->hasAttribute("minOccurs")) {
            $ref->setMin((int) $node->getAttribute("minOccurs"));
        }

        return $ref;
    }

    /**
    * @param int|null $max
    *
    * @return int|null
    */
    abstract protected static function loadSequenceNormaliseMax(DOMElement $node, $max);

    /**
    * @param int|null $max
    */
    abstract protected function loadSequence(ElementContainer $elementContainer, DOMElement $node, $max = null);

    /**
    * @param int|null $max
    */
    abstract protected function loadSequenceChildNode(
        ElementContainer $elementContainer,
        DOMElement $node,
        DOMElement $childNode,
        $max
    );

    /**
    * @param mixed[][] $methods
    *
    * @return mixed
    */
    abstract protected function maybeCallCallableWithArgs(
        DOMElement $childNode,
        array $commonMethods = [],
        array $methods = [],
        array $commonArguments = []
    );

    /**
    * @param int|null $max
    */
    abstract protected function loadSequenceChildNodeLoadSequence(
        ElementContainer $elementContainer,
        DOMElement $childNode,
        $max
    );

    /**
    * @param int|null $max
    */
    abstract protected function loadSequenceChildNodeLoadElement(
        ElementContainer $elementContainer,
        DOMElement $node,
        DOMElement $childNode,
        $max
    );

    abstract protected function loadSequenceChildNodeLoadGroup(
        ElementContainer $elementContainer,
        DOMElement $node,
        DOMElement $childNode
    );

    abstract protected function addGroupAsElement(
        Schema $schema,
        DOMElement $node,
        DOMElement $childNode,
        ElementContainer $elementContainer
    );

    abstract protected function maybeLoadSequenceFromElementContainer(
        BaseComplexType $type,
        DOMElement $childNode
    );

    /**
    * @return Closure
    */
    abstract protected function loadGroup(Schema $schema, DOMElement $node);

    /**
    * @return BaseComplexType
    */
    abstract protected function loadComplexTypeBeforeCallbackCallback(
        Schema $schema,
        DOMElement $node
    );

    /**
    * @param Closure|null $callback
    *
    * @return Closure
    */
    abstract protected function loadComplexType(Schema $schema, DOMElement $node, $callback = null);

    /**
    * @param Closure|null $callback
    *
    * @return Closure
    */
    abstract protected function makeCallbackCallback(
        Type $type,
        DOMElement $node,
        Closure $callbackCallback,
        $callback = null
    );

    /**
    * @param Closure|null $callback
    */
    abstract protected function runCallbackAgainstDOMNodeList(
        Type $type,
        DOMElement $node,
        Closure $againstNodeList,
        $callback = null
    );

    abstract protected function loadComplexTypeFromChildNode(
        BaseComplexType $type,
        DOMElement $node,
        DOMElement $childNode,
        Schema $schema
    );

    /**
    * @param Closure|null $callback
    *
    * @return Closure
    */
    abstract protected function loadSimpleType(Schema $schema, DOMElement $node, $callback = null);

    abstract protected function loadList(SimpleType $type, DOMElement $node);

    /**
    * @param string $attributeName
    *
    * @return SchemaItem
    */
    abstract protected function findSomeType(
        SchemaItem $fromThis,
        DOMElement $node,
        $attributeName
    );

    /**
    * @param string $attributeName
    *
    * @return SchemaItem
    */
    abstract protected function findSomeTypeFromAttribute(
        SchemaItem $fromThis,
        DOMElement $node,
        $attributeName
    );

    abstract protected function loadUnion(SimpleType $type, DOMElement $node);

    /**
    * @param bool $checkAbstract
    */
    abstract protected function fillTypeNode(Type $type, DOMElement $node, $checkAbstract = false);

    abstract protected function loadExtensionChildNode(
        BaseComplexType $type,
        DOMElement $node,
        DOMElement $childNode
    );

    abstract protected function loadExtension(BaseComplexType $type, DOMElement $node);

    abstract protected function loadExtensionChildNodes(
        BaseComplexType $type,
        DOMNodeList $childNodes,
        DOMElement $node
    );

    public function findAndSetSomeBase(
        Type $type,
        Base $setBaseOnThis,
        DOMElement $node
    ) {
        /**
        * @var Type $parent
        */
        $parent = $this->findSomeType($type, $node, 'base');
        $setBaseOnThis->setBase($parent);
    }

    abstract protected function maybeLoadExtensionFromBaseComplexType(
        Type $type,
        DOMElement $childNode
    );

    abstract protected function loadRestriction(Type $type, DOMElement $node);

    /**
    * @param string $typeName
    *
    * @return mixed[]
    */
    abstract protected static function splitParts(DOMElement $node, $typeName);

    /**
     *
     * @param string $finder
     * @param Schema $schema
     * @param DOMElement $node
     * @param string $typeName
     * @throws TypeException
     * @return ElementItem|Group|AttributeItem|AttributeGroup|Type
     */
    public function findSomething($finder, Schema $schema, DOMElement $node, $typeName)
    {
        list ($name, $namespace) = static::splitParts($node, $typeName);

        $namespace = $namespace ?: $schema->getTargetNamespace();

        try {
            return $schema->$finder($name, $namespace);
        } catch (TypeNotFoundException $e) {
            throw new TypeException(sprintf("Can't find %s named {%s}#%s, at line %d in %s ", strtolower(substr($finder, 4)), $namespace, $name, $node->getLineNo(), $node->ownerDocument->documentURI), 0, $e);
        }
    }

    /**
    * @return Closure
    */
    abstract protected function loadElementDef(Schema $schema, DOMElement $node);

    public function fillItem(Item $element, DOMElement $node)
    {
        foreach ($node->childNodes as $childNode) {
            if (
                in_array(
                    $childNode->localName,
                    [
                        'complexType',
                        'simpleType',
                    ]
                )
            ) {
                Type::loadTypeWithCallback(
                    $this,
                    $element->getSchema(),
                    $childNode,
                    function (Type $type) use ($element) {
                        $element->setType($type);
                    }
                );
                return;
            }
        }

        $this->fillItemNonLocalType($element, $node);
    }

    abstract protected function fillItemNonLocalType(Item $element, DOMElement $node);

    /**
    * @var Schema|null
    */
    protected $globalSchema;

    /**
    * @return Schema[]
    */
    protected function setupGlobalSchemas(array & $callbacks)
    {
        $globalSchemas = array();
        foreach (self::$globalSchemaInfo as $namespace => $uri) {
            Schema::setLoadedFile(
                $uri,
                $globalSchemas[$namespace] = $schema = new Schema()
            );
            if ($namespace === self::XSD_NS) {
                $this->globalSchema = $schema;
            }
            $xml = $this->getDOM($this->knownLocationSchemas[$uri]);
            $callbacks = array_merge($callbacks, $this->schemaNode($schema, $xml->documentElement));
        }

        return $globalSchemas;
    }

    /**
    * @return string[]
    */
    public function getGlobalSchemaInfo()
    {
        return self::$globalSchemaInfo;
    }

    /**
     *
     * @return Schema
     */
    public function getGlobalSchema()
    {
        if (!$this->globalSchema) {
            $callbacks = array();
            $globalSchemas = $this->setupGlobalSchemas($callbacks);

            $globalSchemas[static::XSD_NS]->addType(new SimpleType($globalSchemas[static::XSD_NS], "anySimpleType"));
            $globalSchemas[static::XSD_NS]->addType(new SimpleType($globalSchemas[static::XSD_NS], "anyType"));

            $globalSchemas[static::XML_NS]->addSchema($globalSchemas[static::XSD_NS], static::XSD_NS);
            $globalSchemas[static::XSD_NS]->addSchema($globalSchemas[static::XML_NS], static::XML_NS);

            foreach ($callbacks as $callback) {
                $callback();
            }
        }

        /**
        * @var Schema $out
        */
        $out = $this->globalSchema;

        return $out;
    }

    /**
     * @param DOMElement $node
     * @param string  $file
     *
     * @return Schema
     */
    public function readNode(DOMElement $node, $file = 'schema.xsd')
    {
        $fileKey = $node->hasAttribute('targetNamespace') ? $this->getNamespaceSpecificFileIndex($file, $node->getAttribute('targetNamespace')) : $file;
        Schema::setLoadedFile($fileKey, $rootSchema = new Schema());

        $rootSchema->addSchema($this->getGlobalSchema());
        $callbacks = $this->schemaNode($rootSchema, $node);

        foreach ($callbacks as $callback) {
            call_user_func($callback);
        }

        return $rootSchema;
    }

    /**
     * It is possible that a single file contains multiple <xsd:schema/> nodes, for instance in a WSDL file.
     *
     * Each of these  <xsd:schema/> nodes typically target a specific namespace. Append the target namespace to the
     * file to distinguish between multiple schemas in a single file.
     *
     * @param string $file
     * @param string $targetNamespace
     *
     * @return string
     */
    public function getNamespaceSpecificFileIndex($file, $targetNamespace)
    {
        return $file . '#' . $targetNamespace;
    }

    /**
     * @param string $content
     * @param string $file
     *
     * @return Schema
     *
     * @throws IOException
     */
    public function readString($content, $file = 'schema.xsd')
    {
        $xml = new DOMDocument('1.0', 'UTF-8');
        if (!$xml->loadXML($content)) {
            throw new IOException("Can't load the schema");
        }
        $xml->documentURI = $file;

        return $this->readNode($xml->documentElement, $file);
    }

    /**
     * @param string $file
     *
     * @return Schema
     */
    public function readFile($file)
    {
        $xml = $this->getDOM($file);
        return $this->readNode($xml->documentElement, $file);
    }

    /**
     * @param string $file
     *
     * @return DOMDocument
     *
     * @throws IOException
     */
    public function getDOM($file)
    {
        $xml = new DOMDocument('1.0', 'UTF-8');
        if (!$xml->load($file)) {
            throw new IOException("Can't load the file $file");
        }
        return $xml;
    }
}


1			<?php
2			namespace GoetasWebservices\XML\XSDReader;
3
4			use Closure;
5			use DOMDocument;
6			use DOMElement;
7			use DOMNode;
8			use DOMNodeList;
9			use GoetasWebservices\XML\XSDReader\Exception\IOException;
10			use GoetasWebservices\XML\XSDReader\Exception\TypeException;
11			use GoetasWebservices\XML\XSDReader\Schema\Attribute\Attribute;
12			use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeDef;
13			use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeItem;
14			use GoetasWebservices\XML\XSDReader\Schema\Attribute\Group as AttributeGroup;
15			use GoetasWebservices\XML\XSDReader\Schema\Element\Element;
16			use GoetasWebservices\XML\XSDReader\Schema\Element\ElementContainer;
17			use GoetasWebservices\XML\XSDReader\Schema\Element\ElementDef;
18			use GoetasWebservices\XML\XSDReader\Schema\Element\ElementItem;
19			use GoetasWebservices\XML\XSDReader\Schema\Element\ElementRef;
20			use GoetasWebservices\XML\XSDReader\Schema\Element\Group;
21			use GoetasWebservices\XML\XSDReader\Schema\Element\GroupRef;
22			use GoetasWebservices\XML\XSDReader\Schema\Element\InterfaceSetMinMax;
23			use GoetasWebservices\XML\XSDReader\Schema\Exception\TypeNotFoundException;
24			use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Base;
25			use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Extension;
26			use GoetasWebservices\XML\XSDReader\Schema\Inheritance\Restriction;
27			use GoetasWebservices\XML\XSDReader\Schema\Item;
28			use GoetasWebservices\XML\XSDReader\Schema\Schema;
29			use GoetasWebservices\XML\XSDReader\Schema\SchemaItem;
30			use GoetasWebservices\XML\XSDReader\Schema\Type\BaseComplexType;
31			use GoetasWebservices\XML\XSDReader\Schema\Type\ComplexType;
32			use GoetasWebservices\XML\XSDReader\Schema\Type\ComplexTypeSimpleContent;
33			use GoetasWebservices\XML\XSDReader\Schema\Type\SimpleType;
34			use GoetasWebservices\XML\XSDReader\Schema\Type\Type;
35			use GoetasWebservices\XML\XSDReader\Utils\UrlUtils;
36			use RuntimeException;
37
38			abstract class AbstractSchemaReader
39			{
40
41			const XSD_NS = "http://www.w3.org/2001/XMLSchema";
42
43			const XML_NS = "http://www.w3.org/XML/1998/namespace";
44
45			/**
46			* @var string[]
47			*/
48			protected $knownLocationSchemas = [
49			'http://www.w3.org/2001/xml.xsd' => (
50			__DIR__ . '/Resources/xml.xsd'
51			),
52			'http://www.w3.org/2001/XMLSchema.xsd' => (
53			__DIR__ . '/Resources/XMLSchema.xsd'
54			),
55			'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd' => (
56			__DIR__ . '/Resources/oasis-200401-wss-wssecurity-secext-1.0.xsd'
57			),
58			'http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd' => (
59			__DIR__ . '/Resources/oasis-200401-wss-wssecurity-utility-1.0.xsd'
60			),
61			'https://www.w3.org/TR/xmldsig-core/xmldsig-core-schema.xsd' => (
62			__DIR__ . '/Resources/xmldsig-core-schema.xsd'
63			),
64			'http://www.w3.org/TR/xmldsig-core/xmldsig-core-schema.xsd' => (
65			__DIR__ . '/Resources/xmldsig-core-schema.xsd'
66			),
67			];
68
69			/**
70			* @var string[]
71			*/
72			protected static $globalSchemaInfo = array(
73			self::XML_NS => 'http://www.w3.org/2001/xml.xsd',
74			self::XSD_NS => 'http://www.w3.org/2001/XMLSchema.xsd'
75			);
76
77			/**
78			* @param string $remote
79			* @param string $local
80			*/
81			public function addKnownSchemaLocation($remote, $local)
82			{
83			$this->knownLocationSchemas[$remote] = $local;
84			}
85
86			/**
87			* @param string $remote
88			*
89			* @return bool
90			*/
91			public function hasKnownSchemaLocation($remote)
92			{
93			return isset($this->knownLocationSchemas[$remote]);
94			}
95
96			/**
97			* @param string $remote
98			*
99			* @return string
100			*/
101			public function getKnownSchemaLocation($remote)
102			{
103			return $this->knownLocationSchemas[$remote];
104			}
105
106			/**
107			* @return Closure
108			*/
109			abstract protected function loadAttributeGroup(Schema $schema, DOMElement $node);
110
111			/**
112			* @param bool $attributeDef
113			*
114			* @return Closure
115			*/
116			abstract protected function loadAttributeOrElementDef(
117			Schema $schema,
118			DOMElement $node,
119			$attributeDef
120			);
121
122			/**
123			* @return Closure
124			*/
125			abstract protected function loadAttributeDef(Schema $schema, DOMElement $node);
126
127			/**
128			* @param DOMElement $node
129			* @return string
130			*/
131			public static function getDocumentation(DOMElement $node)
132			{
133			$doc = '';
134			foreach ($node->childNodes as $childNode) {
135			if ($childNode->localName == "annotation") {
136			$doc .= static::getDocumentation($childNode);
137			} elseif ($childNode->localName == 'documentation') {
138			$doc .= ($childNode->nodeValue);
139			}
140			}
141			$doc = preg_replace('/[\t ]+/', ' ', $doc);
142			return trim($doc);
143			}
144
145			/**
146			* @param string $key
147			*
148			* @return Closure\|null
149			*/
150			public function maybeCallMethod(
151			array $methods,
152			$key,
153			DOMNode $childNode,
154			...$args
155			) {
156			if ($childNode instanceof DOMElement && isset($methods[$key])) {
157			$method = $methods[$key];
158
159			$append = $this->$method(...$args);
160
161			if ($append instanceof Closure) {
162			return $append;
163			}
164			}
165			}
166
167			/**
168			*
169			* @param Schema $schema
170			* @param DOMElement $node
171			* @param Schema $parent
172			* @return Closure[]
173			*/
174			public function schemaNode(Schema $schema, DOMElement $node, Schema $parent = null)
175			{
176			$schema->setSchemaThingsFromNode($node, $parent);
177			$functions = array();
178
179			$schemaReaderMethods = [
180			'include' => (Schema::class . '::loadImport'),
181			'import' => (Schema::class . '::loadImport'),
182			];
183
184			$thisMethods = [
185			'element' => [$this, 'loadElementDef'],
186			'attribute' => [$this, 'loadAttributeDef'],
187			'attributeGroup' => [$this, 'loadAttributeGroup'],
188			'group' => [$this, 'loadGroup'],
189			'complexType' => [$this, 'loadComplexType'],
190			'simpleType' => [$this, 'loadSimpleType'],
191			];
192
193			foreach ($node->childNodes as $childNode) {
194			if ($childNode instanceof DOMElement) {
195			$callback = $this->maybeCallCallableWithArgs(
196			$childNode,
197			[],
198			[],
199			[
200			[
201			$schemaReaderMethods,
202			[
203			$this,
204			$schema,
205			$childNode,
206			]
207			],
208			[
209			$thisMethods,
210			[
211			$schema,
212			$childNode
213			],
214			],
215			]
216			);
217
218			if ($callback instanceof Closure) {
219			$functions[] = $callback;
220			}
221			}
222			}
223
224			return $functions;
225			}
226
227			/**
228			* @return InterfaceSetMinMax
229			*/
230			public static function maybeSetMax(InterfaceSetMinMax $ref, DOMElement $node)
231			{
232			if (
233			$node->hasAttribute("maxOccurs")
234			) {
235			$ref->setMax($node->getAttribute("maxOccurs") == "unbounded" ? -1 : (int)$node->getAttribute("maxOccurs"));
236			}
237
238			return $ref;
239			}
240
241			/**
242			* @return InterfaceSetMinMax
243			*/
244			public static function maybeSetMin(InterfaceSetMinMax $ref, DOMElement $node)
245			{
246			if ($node->hasAttribute("minOccurs")) {
247			$ref->setMin((int) $node->getAttribute("minOccurs"));
248			}
249
250			return $ref;
251			}
252
253			/**
254			* @param int\|null $max
255			*
256			* @return int\|null
257			*/
258			abstract protected static function loadSequenceNormaliseMax(DOMElement $node, $max);
259
260			/**
261			* @param int\|null $max
262			*/
263			abstract protected function loadSequence(ElementContainer $elementContainer, DOMElement $node, $max = null);
264
265			/**
266			* @param int\|null $max
267			*/
268			abstract protected function loadSequenceChildNode(
269			ElementContainer $elementContainer,
270			DOMElement $node,
271			DOMElement $childNode,
272			$max
273			);
274
275			/**
276			* @param mixed[][] $methods
277			*
278			* @return mixed
279			*/
280			abstract protected function maybeCallCallableWithArgs(
281			DOMElement $childNode,
282			array $commonMethods = [],
283			array $methods = [],
284			array $commonArguments = []
285			);
286
287			/**
288			* @param int\|null $max
289			*/
290			abstract protected function loadSequenceChildNodeLoadSequence(
291			ElementContainer $elementContainer,
292			DOMElement $childNode,
293			$max
294			);
295
296			/**
297			* @param int\|null $max
298			*/
299			abstract protected function loadSequenceChildNodeLoadElement(
300			ElementContainer $elementContainer,
301			DOMElement $node,
302			DOMElement $childNode,
303			$max
304			);
305
306			abstract protected function loadSequenceChildNodeLoadGroup(
307			ElementContainer $elementContainer,
308			DOMElement $node,
309			DOMElement $childNode
310			);
311
312			abstract protected function addGroupAsElement(
313			Schema $schema,
314			DOMElement $node,
315			DOMElement $childNode,
316			ElementContainer $elementContainer
317			);
318
319			abstract protected function maybeLoadSequenceFromElementContainer(
320			BaseComplexType $type,
321			DOMElement $childNode
322			);
323
324			/**
325			* @return Closure
326			*/
327			abstract protected function loadGroup(Schema $schema, DOMElement $node);
328
329			/**
330			* @return BaseComplexType
331			*/
332			abstract protected function loadComplexTypeBeforeCallbackCallback(
333			Schema $schema,
334			DOMElement $node
335			);
336
337			/**
338			* @param Closure\|null $callback
339			*
340			* @return Closure
341			*/
342			abstract protected function loadComplexType(Schema $schema, DOMElement $node, $callback = null);
343
344			/**
345			* @param Closure\|null $callback
346			*
347			* @return Closure
348			*/
349			abstract protected function makeCallbackCallback(
350			Type $type,
351			DOMElement $node,
352			Closure $callbackCallback,
353			$callback = null
354			);
355
356			/**
357			* @param Closure\|null $callback
358			*/
359			abstract protected function runCallbackAgainstDOMNodeList(
360			Type $type,
361			DOMElement $node,
362			Closure $againstNodeList,
363			$callback = null
364			);
365
366			abstract protected function loadComplexTypeFromChildNode(
367			BaseComplexType $type,
368			DOMElement $node,
369			DOMElement $childNode,
370			Schema $schema
371			);
372
373			/**
374			* @param Closure\|null $callback
375			*
376			* @return Closure
377			*/
378			abstract protected function loadSimpleType(Schema $schema, DOMElement $node, $callback = null);
379
380			abstract protected function loadList(SimpleType $type, DOMElement $node);
381
382			/**
383			* @param string $attributeName
384			*
385			* @return SchemaItem
386			*/
387			abstract protected function findSomeType(
388			SchemaItem $fromThis,
389			DOMElement $node,
390			$attributeName
391			);
392
393			/**
394			* @param string $attributeName
395			*
396			* @return SchemaItem
397			*/
398			abstract protected function findSomeTypeFromAttribute(
399			SchemaItem $fromThis,
400			DOMElement $node,
401			$attributeName
402			);
403
404			abstract protected function loadUnion(SimpleType $type, DOMElement $node);
405
406			/**
407			* @param bool $checkAbstract
408			*/
409			abstract protected function fillTypeNode(Type $type, DOMElement $node, $checkAbstract = false);
410
411			abstract protected function loadExtensionChildNode(
412			BaseComplexType $type,
413			DOMElement $node,
414			DOMElement $childNode
415			);
416
417			abstract protected function loadExtension(BaseComplexType $type, DOMElement $node);
418
419			abstract protected function loadExtensionChildNodes(
420			BaseComplexType $type,
421			DOMNodeList $childNodes,
422			DOMElement $node
423			);
424
425			public function findAndSetSomeBase(
426			Type $type,
427			Base $setBaseOnThis,
428			DOMElement $node
429			) {
430			/**
431			* @var Type $parent
432			*/
433			$parent = $this->findSomeType($type, $node, 'base');
434			$setBaseOnThis->setBase($parent);
435			}
436
437			abstract protected function maybeLoadExtensionFromBaseComplexType(
438			Type $type,
439			DOMElement $childNode
440			);
441
442			abstract protected function loadRestriction(Type $type, DOMElement $node);
443
444			/**
445			* @param string $typeName
446			*
447			* @return mixed[]
448			*/
449			abstract protected static function splitParts(DOMElement $node, $typeName);
450
451			/**
452			*
453			* @param string $finder
454			* @param Schema $schema
455			* @param DOMElement $node
456			* @param string $typeName
457			* @throws TypeException
458			* @return ElementItem\|Group\|AttributeItem\|AttributeGroup\|Type
459			*/
460			public function findSomething($finder, Schema $schema, DOMElement $node, $typeName)
461			{
462			list ($name, $namespace) = static::splitParts($node, $typeName);
463
464			$namespace = $namespace ?: $schema->getTargetNamespace();
465
466			try {
467			return $schema->$finder($name, $namespace);
468			} catch (TypeNotFoundException $e) {
469			throw new TypeException(sprintf("Can't find %s named {%s}#%s, at line %d in %s ", strtolower(substr($finder, 4)), $namespace, $name, $node->getLineNo(), $node->ownerDocument->documentURI), 0, $e);
470			}
471			}
472
473			/**
474			* @return Closure
475			*/
476			abstract protected function loadElementDef(Schema $schema, DOMElement $node);
477
478			public function fillItem(Item $element, DOMElement $node)
479			{
480			foreach ($node->childNodes as $childNode) {
481			if (
482			in_array(
483			$childNode->localName,
484			[
485			'complexType',
486			'simpleType',
487			]
488			)
489			) {
490			Type::loadTypeWithCallback(
491			$this,
492			$element->getSchema(),
493			$childNode,
494			function (Type $type) use ($element) {
495			$element->setType($type);
496			}
497			);
498			return;
499			}
500			}
501
502			$this->fillItemNonLocalType($element, $node);
503			}
504
505			abstract protected function fillItemNonLocalType(Item $element, DOMElement $node);
506
507			/**
508			* @var Schema\|null
509			*/
510			protected $globalSchema;
511
512			/**
513			* @return Schema[]
514			*/
515			protected function setupGlobalSchemas(array & $callbacks)
516			{
517			$globalSchemas = array();
518			foreach (self::$globalSchemaInfo as $namespace => $uri) {
519			Schema::setLoadedFile(
520			$uri,
521			$globalSchemas[$namespace] = $schema = new Schema()
522			);
523			if ($namespace === self::XSD_NS) {
524			$this->globalSchema = $schema;
525			}
526			$xml = $this->getDOM($this->knownLocationSchemas[$uri]);
527			$callbacks = array_merge($callbacks, $this->schemaNode($schema, $xml->documentElement));
528			}
529
530			return $globalSchemas;
531			}
532
533			/**
534			* @return string[]
535			*/
536			public function getGlobalSchemaInfo()
537			{
538			return self::$globalSchemaInfo;
539			}
540
541			/**
542			*
543			* @return Schema
544			*/
545			public function getGlobalSchema()
546			{
547			if (!$this->globalSchema) {
548			$callbacks = array();
549			$globalSchemas = $this->setupGlobalSchemas($callbacks);
550
551			$globalSchemas[static::XSD_NS]->addType(new SimpleType($globalSchemas[static::XSD_NS], "anySimpleType"));
552			$globalSchemas[static::XSD_NS]->addType(new SimpleType($globalSchemas[static::XSD_NS], "anyType"));
553
554			$globalSchemas[static::XML_NS]->addSchema($globalSchemas[static::XSD_NS], static::XSD_NS);
555			$globalSchemas[static::XSD_NS]->addSchema($globalSchemas[static::XML_NS], static::XML_NS);
556
557			foreach ($callbacks as $callback) {
558			$callback();
559			}
560			}
561
562			/**
563			* @var Schema $out
564			*/
565			$out = $this->globalSchema;
566
567			return $out;
568			}
569
570			/**
571			* @param DOMElement $node
572			* @param string $file
573			*
574			* @return Schema
575			*/
576			public function readNode(DOMElement $node, $file = 'schema.xsd')
577			{
578			$fileKey = $node->hasAttribute('targetNamespace') ? $this->getNamespaceSpecificFileIndex($file, $node->getAttribute('targetNamespace')) : $file;
579			Schema::setLoadedFile($fileKey, $rootSchema = new Schema());
580
581			$rootSchema->addSchema($this->getGlobalSchema());
582			$callbacks = $this->schemaNode($rootSchema, $node);
583
584			foreach ($callbacks as $callback) {
585			call_user_func($callback);
586			}
587
588			return $rootSchema;
589			}
590
591			/**
592			* It is possible that a single file contains multiple <xsd:schema/> nodes, for instance in a WSDL file.
593			*
594			* Each of these <xsd:schema/> nodes typically target a specific namespace. Append the target namespace to the
595			* file to distinguish between multiple schemas in a single file.
596			*
597			* @param string $file
598			* @param string $targetNamespace
599			*
600			* @return string
601			*/
602			public function getNamespaceSpecificFileIndex($file, $targetNamespace)
603			{
604			return $file . '#' . $targetNamespace;
605			}
606
607			/**
608			* @param string $content
609			* @param string $file
610			*
611			* @return Schema
612			*
613			* @throws IOException
614			*/
615			public function readString($content, $file = 'schema.xsd')
616			{
617			$xml = new DOMDocument('1.0', 'UTF-8');
618			if (!$xml->loadXML($content)) {
619			throw new IOException("Can't load the schema");
620			}
621			$xml->documentURI = $file;
622
623			return $this->readNode($xml->documentElement, $file);
624			}
625
626			/**
627			* @param string $file
628			*
629			* @return Schema
630			*/
631			public function readFile($file)
632			{
633			$xml = $this->getDOM($file);
634			return $this->readNode($xml->documentElement, $file);
635			}
636
637			/**
638			* @param string $file
639			*
640			* @return DOMDocument
641			*
642			* @throws IOException
643			*/
644			public function getDOM($file)
645			{
646			$xml = new DOMDocument('1.0', 'UTF-8');
647			if (!$xml->load($file)) {
648			throw new IOException("Can't load the file $file");
649			}
650			return $xml;
651			}
652			}
653

goetas-webservices / xsd-reader

Pull Request — master (#18)

AbstractSchemaReader::fillItem() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like