SchemaReaderCallbackAbstraction::runCallbackAgainstDOMNodeList() - Code Metrics - Inspection of "avoid running php-cs-fixer on hhvm, no need to all..." - SignpostMarv/xsd-reader - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — static-analysis ( ccdceb...ae16b7 )

by SignpostMarv

created 2017-10-28 10:00 UTC

runCallbackAgainstDOMNodeList() A

↳ Parent: SchemaReaderCallbackAbstraction

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
cc	2
eloc	4
c	0
b	0
f	0
nc	2
nop	4
dl	0
loc	12
ccs	5
cts	5
cp	1
crap	2
rs	9.4285

<?php

namespace GoetasWebservices\XML\XSDReader;

use Closure;
use DOMElement;
use GoetasWebservices\XML\XSDReader\Schema\Element\ElementContainer;
use GoetasWebservices\XML\XSDReader\Schema\Type\BaseComplexType;
use GoetasWebservices\XML\XSDReader\Schema\Type\Type;
use RuntimeException;

abstract class SchemaReaderCallbackAbstraction extends AbstractSchemaReader
{
    /**
     * @param mixed[][] $commonMethods
     * @param mixed[][] $methods
     * @param mixed[][] $commonArguments
     *
     * @return mixed
     */
    protected function maybeCallCallableWithArgs(
        DOMElement $childNode,
        array $commonMethods = [],
        array $methods = [],
        array $commonArguments = []
    ) {
        foreach ($commonMethods as $commonMethodsSpec) {
            list($localNames, $callable, $args) = $commonMethodsSpec;

            /**
             * @var string[]
             */
            $localNames = $localNames;

            /**
             * @var callable
             */
            $callable = $callable;

            /**
             * @var mixed[]
             */
            $args = $args;

            if (in_array($childNode->localName, $localNames)) {
                return call_user_func_array($callable, $args);
            }
        }
        foreach ($commonArguments as $commonArgumentSpec) {
            /*
            * @var mixed[] $commonArgumentSpec
            */
            list($callables, $args) = $commonArgumentSpec;

            /**
             * @var callable[]
             */
            $callables = $callables;

            /**
             * @var mixed[]
             */
            $args = $args;

            if (isset($callables[$childNode->localName])) {
                return call_user_func_array(
                    $callables[$childNode->localName],
                    $args
                );
            }
        }
        if (isset($methods[$childNode->localName])) {
            list($callable, $args) = $methods[$childNode->localName];

            /**
             * @var callable
             */
            $callable = $callable;

            /**
             * @var mixed[]
             */
            $args = $args;

            return call_user_func_array($callable, $args);
        }
    }

    protected function maybeLoadSequenceFromElementContainer(
        BaseComplexType $type,
        DOMElement $childNode
    ) {
        $this->maybeLoadThingFromThing(
            $type,
            $childNode,
            ElementContainer::class,
            'loadSequence'
        );
    }

    /**
     * @param string $instanceof
     * @param string $passTo
     */
    protected function maybeLoadThingFromThing(
        Type $type,
        DOMElement $childNode,
        $instanceof,
        $passTo
    ) {
        if (!is_a($type, $instanceof, true)) {
            /**
             * @var string
             */
            $class = static::class;
            throw new RuntimeException(
                'Argument 1 passed to '.
                __METHOD__.
                ' needs to be an instance of '.
                $instanceof.
                ' when passed onto '.
                $class.
                '::'.
                $passTo.
                '(), '.
                (string) get_class($type).
                ' given.'
            );
        }

        $this->$passTo($type, $childNode);
    }

    /**
     * @param Closure|null $callback
     *
     * @return Closure
     */
    protected function makeCallbackCallback(
        Type $type,
        DOMElement $node,
        Closure $callbackCallback,
        $callback = null
    ) {
        return function (
        ) use (
            $type,
            $node,
            $callbackCallback,
            $callback
        ) {
            $this->runCallbackAgainstDOMNodeList(
                $type,
                $node,
                $callbackCallback,
                $callback
            );
        };
    }

    /**
     * @param Closure|null $callback
     */
    protected function runCallbackAgainstDOMNodeList(
        Type $type,
        DOMElement $node,
        Closure $againstNodeList,
        $callback = null
    ) {
        $this->fillTypeNode($type, $node, true);

        static::againstDOMNodeList($node, $againstNodeList);

        if ($callback) {
            call_user_func($callback, $type);
        }
    }

    protected function maybeLoadExtensionFromBaseComplexType(
        Type $type,
        DOMElement $childNode
    ) {
        $this->maybeLoadThingFromThing(
            $type,
            $childNode,
            BaseComplexType::class,
            'loadExtension'
        );
    }
}


1		<?php
2
3		namespace GoetasWebservices\XML\XSDReader;
4
5		use Closure;
6		use DOMElement;
7		use GoetasWebservices\XML\XSDReader\Schema\Element\ElementContainer;
8		use GoetasWebservices\XML\XSDReader\Schema\Type\BaseComplexType;
9		use GoetasWebservices\XML\XSDReader\Schema\Type\Type;
10		use RuntimeException;
11
12		abstract class SchemaReaderCallbackAbstraction extends AbstractSchemaReader
13		{
14		/**
15		* @param mixed[][] $commonMethods
16		* @param mixed[][] $methods
17		* @param mixed[][] $commonArguments
18		*
19		* @return mixed
20		*/
21	135	protected function maybeCallCallableWithArgs(
22		DOMElement $childNode,
23		array $commonMethods = [],
24		array $methods = [],
25		array $commonArguments = []
26		) {
27	135	foreach ($commonMethods as $commonMethodsSpec) {
28	135	list($localNames, $callable, $args) = $commonMethodsSpec;
29
30		/**
31		* @var string[]
32		*/
33	135	$localNames = $localNames;
34
35		/**
36		* @var callable
37		*/
38	135	$callable = $callable;
39
40		/**
41		* @var mixed[]
42		*/
43	135	$args = $args;
44
45	135	if (in_array($childNode->localName, $localNames)) {
46	135	return call_user_func_array($callable, $args);
47		}
48	45	}
49	135	foreach ($commonArguments as $commonArgumentSpec) {
50		/*
51		* @var mixed[] $commonArgumentSpec
52		*/
53	135	list($callables, $args) = $commonArgumentSpec;
54
55		/**
56		* @var callable[]
57		*/
58	135	$callables = $callables;
59
60		/**
61		* @var mixed[]
62		*/
63	135	$args = $args;
64
65	135	if (isset($callables[$childNode->localName])) {
66	135	return call_user_func_array(
67	135	$callables[$childNode->localName],
68	90	$args
69	45	);
70		}
71	45	}
72	135	if (isset($methods[$childNode->localName])) {
73	135	list($callable, $args) = $methods[$childNode->localName];
74
75		/**
76		* @var callable
77		*/
78	135	$callable = $callable;
79
80		/**
81		* @var mixed[]
82		*/
83	135	$args = $args;
84
85	135	return call_user_func_array($callable, $args);
86		}
87	135	}
88
89	135	protected function maybeLoadSequenceFromElementContainer(
90		BaseComplexType $type,
91		DOMElement $childNode
92		) {
93	135	$this->maybeLoadThingFromThing(
94	135	$type,
95	135	$childNode,
96	135	ElementContainer::class,
97	90	'loadSequence'
98	45	);
99	135	}
100
101		/**
102		* @param string $instanceof
103		* @param string $passTo
104		*/
105	135	protected function maybeLoadThingFromThing(
106		Type $type,
107		DOMElement $childNode,
108		$instanceof,
109		$passTo
110		) {
111	135	if (!is_a($type, $instanceof, true)) {
112		/**
113		* @var string
114		*/
115		$class = static::class;
116		throw new RuntimeException(
117		'Argument 1 passed to '.
118		__METHOD__.
119		' needs to be an instance of '.
120		$instanceof.
121		' when passed onto '.
122		$class.
123		'::'.
124		$passTo.
125		'(), '.
126		(string) get_class($type).
127		' given.'
128		);
129		}
130
131	135	$this->$passTo($type, $childNode);
132	135	}
133
134		/**
135		* @param Closure\|null $callback
136		*
137		* @return Closure
138		*/
139		protected function makeCallbackCallback(
140		Type $type,
141		DOMElement $node,
142		Closure $callbackCallback,
143		$callback = null
144		) {
145	135	return function (
146		) use (
147	135	$type,
148	135	$node,
149	135	$callbackCallback,
150	135	$callback
151		) {
152	135	$this->runCallbackAgainstDOMNodeList(
153	135	$type,
154	135	$node,
155	135	$callbackCallback,
156	90	$callback
157	45	);
158	135	};
159		}
160
161		/**
162		* @param Closure\|null $callback
163		*/
164	135	protected function runCallbackAgainstDOMNodeList(
165		Type $type,
166		DOMElement $node,
167		Closure $againstNodeList,
168		$callback = null
169		) {
170	135	$this->fillTypeNode($type, $node, true);
171
172	135	static::againstDOMNodeList($node, $againstNodeList);
173
174	135	if ($callback) {
175	135	call_user_func($callback, $type);
176	45	}
177	135	}
178
179	135	protected function maybeLoadExtensionFromBaseComplexType(
180		Type $type,
181		DOMElement $childNode
182		) {
183	135	$this->maybeLoadThingFromThing(
184	135	$type,
185	135	$childNode,
186	135	BaseComplexType::class,
187	90	'loadExtension'
188	45	);
189	135	}
190		}
191

SignpostMarv / xsd-reader

Push — static-analysis ( ccdceb...ae16b7 )

runCallbackAgainstDOMNodeList() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like