Schema::loadImportFreshCallbacksNewSchema() - 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

Schema::loadImportFreshCallbacksNewSchema() A

↳ Parent: Schema

Complexity

Conditions	3
Paths	2

Size

Total Lines	17
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	3

Importance

Changes

Metric	Value
cc	3
eloc	7
nc	2
nop	4
dl	0
loc	17
ccs	10
cts	10
cp	1
crap	3
rs	9.4285
c	0
b	0
f	0

<?php
namespace GoetasWebservices\XML\XSDReader\Schema;

use Closure;
use DOMElement;
use RuntimeException;
use GoetasWebservices\XML\XSDReader\AbstractSchemaReader;
use GoetasWebservices\XML\XSDReader\SchemaReaderLoadAbstraction;
use GoetasWebservices\XML\XSDReader\Schema\Type\Type;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\Group as AttributeGroup;
use GoetasWebservices\XML\XSDReader\Schema\Element\Group;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementDef;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementItem;
use GoetasWebservices\XML\XSDReader\Schema\Exception\TypeNotFoundException;
use GoetasWebservices\XML\XSDReader\Schema\Exception\SchemaException;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeItem;
use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeDef;
use GoetasWebservices\XML\XSDReader\Utils\UrlUtils;

class Schema extends AbstractSchema
filter:
    dependency_paths: ["lib/*"]
{
    /**
    * {@inheritdoc}
    */
    protected function findSomethingNoThrow(
        $getter,
        $name,
        $namespace = null,
        array & $calling = array()
    ) {
        $calling[spl_object_hash($this)] = true;
        $cid = "$getter, $name, $namespace";

        if (isset($this->typeCache[$cid])) {
            return $this->typeCache[$cid];
        } elseif (
            $this->getTargetNamespace() === $namespace &&
            (($item = $this->$getter($name)) instanceof SchemaItem)
        ) {
            return $this->typeCache[$cid] = $item;

        }

        return $this->findSomethingNoThrowSchemas(
            $this->getSchemas(),
            $cid,
            $getter,
            $name,
            $namespace,
            $calling
        );
    }


    /**
    * {@inheritdoc}
    */
    protected function findSomethingNoThrowSchemas(
        array $schemas,
        $cid,
        $getter,
        $name,
        $namespace = null,
        array & $calling = array()
    ) {
        foreach ($schemas as $childSchema) {
            if (!isset($calling[spl_object_hash($childSchema)])) {
                $in = $childSchema->findSomethingNoThrow($getter, $name, $namespace, $calling);

                if ($in instanceof SchemaItem) {
                    return $this->typeCache[$cid] = $in;

                }
            }
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function findSomething($getter, $name, $namespace = null, &$calling = array())
    {
        $in = $this->findSomethingNoThrow(
            $getter,
            $name,
            $namespace,
            $calling
        );

        if ($in instanceof SchemaItem) {
            return $in;
        }

        throw new TypeNotFoundException(sprintf("Can't find the %s named {%s}#%s.", substr($getter, 3), $namespace, $name));
    }

    /**
    * {@inheritdoc}
    */
    protected static function loadImportFreshKeys(
        SchemaReaderLoadAbstraction $reader,
        $namespace,
        $file
    ) {
        $globalSchemaInfo = $reader->getGlobalSchemaInfo();

        $keys = [];

        if (isset($globalSchemaInfo[$namespace])) {
            $keys[] = $globalSchemaInfo[$namespace];
        }

        $keys[] = $reader->getNamespaceSpecificFileIndex(
            $file,
            $namespace
        );

        $keys[] = $file;

        return $keys;
    }

    /**
    * {@inheritdoc}
    */
    protected static function loadImportFreshCallbacksNewSchema(
        $namespace,
        SchemaReaderLoadAbstraction $reader,
        Schema $schema,
        $file
    ) {
        $newSchema = Schema::setLoadedFile(
            $file,
            ($namespace ? new Schema() : $schema)
        );

        if ($namespace) {
            $newSchema->addSchema($reader->getGlobalSchema());
            $schema->addSchema($newSchema);
        }

        return $newSchema;
    }

    /**
    * {@inheritdoc}
    */
    protected static function loadImportFreshCallbacks(
        $namespace,
        SchemaReaderLoadAbstraction $reader,
        Schema $schema,
        $file
    ) {
        return $reader->schemaNode(
            static::loadImportFreshCallbacksNewSchema(
                $namespace,
                $reader,
                $schema,
                $file
            ),
            $reader->getDOM(
                $reader->hasKnownSchemaLocation($file)
                    ? $reader->getKnownSchemaLocation($file)
                    : $file
            )->documentElement,
            $schema
        );
    }

    /**
    * {@inheritdoc}
    */
    protected static function loadImportFresh(
        $namespace,
        SchemaReaderLoadAbstraction $reader,
        Schema $schema,
        $file
    ) {
        return function () use ($namespace, $reader, $schema, $file) {
            foreach (
                static::loadImportFreshCallbacks(
                    $namespace,
                    $reader,
                    $schema,
                    $file
                ) as $callback
            ) {
                $callback();
            }
        };
    }
}


1		<?php
2		namespace GoetasWebservices\XML\XSDReader\Schema;
3
4		use Closure;
5		use DOMElement;
6		use RuntimeException;
7		use GoetasWebservices\XML\XSDReader\AbstractSchemaReader;
8		use GoetasWebservices\XML\XSDReader\SchemaReaderLoadAbstraction;
9		use GoetasWebservices\XML\XSDReader\Schema\Type\Type;
10		use GoetasWebservices\XML\XSDReader\Schema\Attribute\Group as AttributeGroup;
11		use GoetasWebservices\XML\XSDReader\Schema\Element\Group;
12		use GoetasWebservices\XML\XSDReader\Schema\Element\ElementDef;
13		use GoetasWebservices\XML\XSDReader\Schema\Element\ElementItem;
14		use GoetasWebservices\XML\XSDReader\Schema\Exception\TypeNotFoundException;
15		use GoetasWebservices\XML\XSDReader\Schema\Exception\SchemaException;
16		use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeItem;
17		use GoetasWebservices\XML\XSDReader\Schema\Attribute\AttributeDef;
18		use GoetasWebservices\XML\XSDReader\Utils\UrlUtils;
19
20		class Schema extends AbstractSchema
		0 ignored issues – show Bug introduced 2017-10-20 22:03 UTC by Report Bug Copy Issue Report The type `GoetasWebservices\XML\XS...r\Schema\AbstractSchema` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
21		{
22		/**
23		* {@inheritdoc}
24		*/
25		protected function findSomethingNoThrow(
26		$getter,
27		$name,
28		$namespace = null,
29		array & $calling = array()
30		) {
31		$calling[spl_object_hash($this)] = true;
32		$cid = "$getter, $name, $namespace";
33
34		if (isset($this->typeCache[$cid])) {
35		return $this->typeCache[$cid];
36		} elseif (
37		$this->getTargetNamespace() === $namespace &&
38		(($item = $this->$getter($name)) instanceof SchemaItem)
39		) {
40		return $this->typeCache[$cid] = $item;
		0 ignored issues – show Bug Best Practice introduced 2017-10-20 22:03 UTC by Report Bug Copy Issue Report The property `typeCache` does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly. Loading history...
41		}
42
43		return $this->findSomethingNoThrowSchemas(
44		$this->getSchemas(),
45	45	$cid,
46		$getter,
47	45	$name,
48	45	$namespace,
49		$calling
50		);
51		}
52
53
54		/**
55	45	* {@inheritdoc}
56		*/
57	45	protected function findSomethingNoThrowSchemas(
58	45	array $schemas,
59		$cid,
60	45	$getter,
61		$name,
62	45	$namespace = null,
63		array & $calling = array()
64		) {
65	45	foreach ($schemas as $childSchema) {
66		if (!isset($calling[spl_object_hash($childSchema)])) {
67	45	$in = $childSchema->findSomethingNoThrow($getter, $name, $namespace, $calling);
68	45
69		if ($in instanceof SchemaItem) {
70	5	return $this->typeCache[$cid] = $in;
		0 ignored issues – show Bug Best Practice introduced 2017-10-20 22:03 UTC by Report Bug Copy Issue Report The property `typeCache` does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly. Loading history...
71		}
72	5	}
73		}
74		}
75	3
76		/**
77	3	* {@inheritdoc}
78		*/
79		protected function findSomething($getter, $name, $namespace = null, &$calling = array())
80	45	{
81		$in = $this->findSomethingNoThrow(
82	45	$getter,
83		$name,
84		$namespace,
85	1	$calling
86		);
87	1
88		if ($in instanceof SchemaItem) {
89		return $in;
90	2	}
91
92	2	throw new TypeNotFoundException(sprintf("Can't find the %s named {%s}#%s.", substr($getter, 3), $namespace, $name));
93		}
94
95		/**
96		* {@inheritdoc}
97		*/
98		protected static function loadImportFreshKeys(
99		SchemaReaderLoadAbstraction $reader,
100	45	$namespace,
101		$file
102	45	) {
103	45	$globalSchemaInfo = $reader->getGlobalSchemaInfo();
104
105	45	$keys = [];
106
107	45	if (isset($globalSchemaInfo[$namespace])) {
108	45	$keys[] = $globalSchemaInfo[$namespace];
109		}
110	45
111		$keys[] = $reader->getNamespaceSpecificFileIndex(
112	45	$file,
113	45	$namespace
114		);
115	45
116		$keys[] = $file;
117	45
118		return $keys;
119		}
120
121	45	/**
122	45	* {@inheritdoc}
123	45	*/
124	45	protected static function loadImportFreshCallbacksNewSchema(
125		$namespace,
126	45	SchemaReaderLoadAbstraction $reader,
127		Schema $schema,
128	45	$file
129		) {
130	45	$newSchema = Schema::setLoadedFile(
131	45	$file,
132		($namespace ? new Schema() : $schema)
133	45	);
134
135	45	if ($namespace) {
136	45	$newSchema->addSchema($reader->getGlobalSchema());
137		$schema->addSchema($newSchema);
138	45	}
139
140	45	return $newSchema;
141	45	}
142
143	1	/**
144		* {@inheritdoc}
145	1	*/
146		protected static function loadImportFreshCallbacks(
147		$namespace,
148		SchemaReaderLoadAbstraction $reader,
149		Schema $schema,
150		$file
151		) {
152		return $reader->schemaNode(
153	45	static::loadImportFreshCallbacksNewSchema(
154		$namespace,
155	45	$reader,
156	45	$schema,
157		$file
158	1	),
159		$reader->getDOM(
160		$reader->hasKnownSchemaLocation($file)
161		? $reader->getKnownSchemaLocation($file)
162		: $file
163		)->documentElement,
164		$schema
165		);
166	45	}
167
168	45	/**
169	45	* {@inheritdoc}
170		*/
171	1	protected static function loadImportFresh(
172		$namespace,
173		SchemaReaderLoadAbstraction $reader,
174		Schema $schema,
175		$file
176		) {
177		return function () use ($namespace, $reader, $schema, $file) {
178		foreach (
179	45	static::loadImportFreshCallbacks(
180		$namespace,
181	45	$reader,
182	45	$schema,
183		$file
184	1	) as $callback
185		) {
186		$callback();
187		}
188		};
189		}
190		}
191

goetas-webservices / xsd-reader

Pull Request — master (#18)

Schema::loadImportFreshCallbacksNewSchema() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like