HookManager::addPreValidator() - Code Metrics - Inspection of "Update documentation." - consolidation/annotated-command - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 303d3b...22ea3e )

by Greg

created 2016-09-15 16:51 UTC

HookManager::addPreValidator() A

↳ Parent: HookManager

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	2

<?php
namespace Consolidation\AnnotatedCommand\Hooks;

use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

use Symfony\Component\Console\ConsoleEvents;
use Symfony\Component\Console\Event\ConsoleCommandEvent;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;

use Consolidation\AnnotatedCommand\ExitCodeInterface;
use Consolidation\AnnotatedCommand\OutputDataInterface;
use Consolidation\AnnotatedCommand\AnnotationData;

/**
 * Manage named callback hooks
 */
class HookManager implements EventSubscriberInterface
{
    protected $hooks = [];

    const PRE_INTERACT = 'pre-interact';
    const INTERACT = 'interact';
    const POST_INTERACT = 'post-interact';
    const PRE_COMMAND_EVENT = 'pre-command';
    const COMMAND_EVENT = 'command';
    const POST_COMMAND_EVENT = 'post-command';
    const PRE_ARGUMENT_VALIDATOR = 'pre-validate';
    const ARGUMENT_VALIDATOR = 'validate';
    const POST_ARGUMENT_VALIDATOR = 'post-validate';
    const PRE_PROCESS_RESULT = 'pre-process';
    const PROCESS_RESULT = 'process';
    const POST_PROCESS_RESULT = 'post-process';
    const PRE_ALTER_RESULT = 'pre-alter';
    const ALTER_RESULT = 'alter';
    const POST_ALTER_RESULT = 'post-alter';
    const STATUS_DETERMINER = 'status';
    const EXTRACT_OUTPUT = 'extract';

    public function __construct()
    {
    }

    /**
     * Add a hook
     *
     * @param mixed $callback The callback function to call
     * @param string   $hook     The name of the hook to add
     * @param string   $name     The name of the command to hook
     *   ('*' for all)
     */
    public function add(callable $callback, $hook, $name = '*')
    {
        $this->hooks[$name][$hook][] = $callback;
    }

    /**
     * Add an interact hook
     *
     * @param type ValidatorInterface $validator
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addInteractor(InteractorInterface $interactor, $name = '*')
    {
        $this->hooks[$name][self::INTERACT][] = $interactor;
    }

    /**
     * Add a pre-validator hook
     *
     * @param type ValidatorInterface $validator
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addPreValidator(ValidatorInterface $validator, $name = '*')
    {
        $this->hooks[$name][self::PRE_ARGUMENT_VALIDATOR][] = $validator;
    }

    /**
     * Add a validator hook
     *
     * @param type ValidatorInterface $validator
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addValidator(ValidatorInterface $validator, $name = '*')
    {
        $this->hooks[$name][self::ARGUMENT_VALIDATOR][] = $validator;
    }

    /**
     * Add a result processor.
     *
     * @param type ProcessResultInterface $resultProcessor
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addResultProcessor(ProcessResultInterface $resultProcessor, $name = '*')
    {
        $this->hooks[$name][self::PROCESS_RESULT][] = $resultProcessor;
    }

    /**
     * Add a result alterer. After a result is processed
     * by a result processor, an alter hook may be used
     * to convert the result from one form to another.
     *
     * @param type AlterResultInterface $resultAlterer
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addAlterResult(AlterResultInterface $resultAlterer, $name = '*')
    {
        $this->hooks[$name][self::ALTER_RESULT][] = $resultAlterer;
    }

    /**
     * Add a status determiner. Usually, a command should return
     * an integer on error, or a result object on success (which
     * implies a status code of zero). If a result contains the
     * status code in some other field, then a status determiner
     * can be used to call the appropriate accessor method to
     * determine the status code.  This is usually not necessary,
     * though; a command that fails may return a CommandError
     * object, which contains a status code and a result message
     * to display.
     * @see CommandError::getExitCode()
     *
     * @param type StatusDeterminerInterface $statusDeterminer
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addStatusDeterminer(StatusDeterminerInterface $statusDeterminer, $name = '*')
    {
        $this->hooks[$name][self::STATUS_DETERMINER][] = $statusDeterminer;
    }

    /**
     * Add an output extractor. If a command returns an object
     * object, by default it is passed directly to the output
     * formatter (if in use) for rendering. If the result object
     * contains more information than just the data to render, though,
     * then an output extractor can be used to call the appopriate
     * accessor method of the result object to get the data to
     * rendered.  This is usually not necessary, though; it is preferable
     * to have complex result objects implement the OutputDataInterface.
     * @see OutputDataInterface::getOutputData()
     *
     * @param type ExtractOutputInterface $outputExtractor
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addOutputExtractor(ExtractOutputInterface $outputExtractor, $name = '*')
    {
        $this->hooks[$name][self::EXTRACT_OUTPUT][] = $outputExtractor;
    }

    public function interact(
        InputInterface $input,
        OutputInterface $output,
        $names,
        AnnotationData $annotationData
    ) {
        $interactors = $this->getInteractors($names, $annotationData);
        foreach ($interactors as $interactor) {
            $this->callInteractor($interactor, $input, $output, $annotationData);
        }
    }

    public function validateArguments($names, $args, AnnotationData $annotationData)

    {
        $validators = $this->getValidators($names, $annotationData);
        foreach ($validators as $validator) {
            $validated = $this->callValidator($validator, $args, $annotationData);
            if (is_object($validated)) {
                return $validated;
            }
            if (is_array($validated)) {
                $args = $validated;
            }
        }
        return $args;
    }

    /**
     * Process result and decide what to do with it.
     * Allow client to add transformation / interpretation
     * callbacks.
     */
    public function alterResult($names, $result, $args, AnnotationData $annotationData)
    {
        $processors = $this->getProcessResultHooks($names, $annotationData);
        foreach ($processors as $processor) {
            $result = $this->callProcessor($processor, $result, $args, $annotationData);
        }
        $alterers = $this->getAlterResultHooks($names, $annotationData);
        foreach ($alterers as $alterer) {
            $result = $this->callProcessor($alterer, $result, $args, $annotationData);
        }

        return $result;
    }

    /**
     * Call all status determiners, and see if any of them
     * know how to convert to a status code.
     */
    public function determineStatusCode($names, $result)
    {
        // If the result (post-processing) is an object that
        // implements ExitCodeInterface, then we will ask it
        // to give us the status code.
        if ($result instanceof ExitCodeInterface) {
            return $result->getExitCode();
        }

        // If the result does not implement ExitCodeInterface,
        // then we'll see if there is a determiner that can
        // extract a status code from the result.
        $determiners = $this->getStatusDeterminers($names);
        foreach ($determiners as $determiner) {
            $status = $this->callDeterminer($determiner, $result);
            if (isset($status)) {
                return $status;
            }
        }
    }

    /**
     * Convert the result object to printable output in
     * structured form.
     */
    public function extractOutput($names, $result)
    {
        if ($result instanceof OutputDataInterface) {
            return $result->getOutputData();
        }

        $extractors = $this->getOutputExtractors($names);
        foreach ($extractors as $extractor) {
            $structuredOutput = $this->callExtractor($extractor, $result);
            if (isset($structuredOutput)) {
                return $structuredOutput;
            }
        }

        return $result;
    }

    protected function getInteractors($names, AnnotationData $annotationData)
    {
        return $this->getHooks($names, self::INTERACT, $annotationData);
    }

    protected function getValidators($names, AnnotationData $annotationData)
    {
        return $this->getHooks($names, self::ARGUMENT_VALIDATOR, $annotationData);
    }

    protected function getStatusDeterminers($names)
    {
        return $this->getHooks($names, self::STATUS_DETERMINER);
    }

    protected function getProcessResultHooks($names, AnnotationData $annotationData)
    {
        return $this->getHooks($names, self::PROCESS_RESULT, $annotationData);
    }

    protected function getAlterResultHooks($names, AnnotationData $annotationData)
    {
        return $this->getHooks($names, self::ALTER_RESULT, $annotationData);
    }

    protected function getOutputExtractors($names)
    {
        return $this->getHooks($names, self::EXTRACT_OUTPUT);
    }

    protected function getCommandEvents($names)
    {
        return $this->getHooks($names, self::COMMAND_EVENT);
    }

    /**
     * Get a set of hooks with the provided name(s). Include the
     * pre- and post- hooks, and also include the global hooks ('*')
     * in addition to the named hooks provided.
     *
     * @param string|array $names The name of the function being hooked.
     * @param string $hook The specific hook name (e.g. alter)
     *
     * @return callable[]
     */
    protected function getHooks($names, $hook, $annotationData = null)
    {
        $names = array_merge(
            (array)$names,
            ($annotationData == null) ? [] : array_map(function ($item) {
                return "@$item";
            }, $annotationData->keys())
        );
        $names[] = '*';
        return array_merge(
            $this->get($names, "pre-$hook"),
            $this->get($names, $hook),
            $this->get($names, "post-$hook")
        );
    }

    /**
     * Get a set of hooks with the provided name(s).
     *
     * @param string|array $names The name of the function being hooked.
     * @param string $hook The specific hook name (e.g. alter)
     *
     * @return callable[]
     */
    public function get($names, $hook)
    {
        $hooks = [];
        foreach ((array)$names as $name) {
            $hooks = array_merge($hooks, $this->getHook($name, $hook));
        }
        return $hooks;
    }

    /**
     * Get a single named hook.
     *
     * @param string $name The name of the hooked method
     * @param string $hook The specific hook name (e.g. alter)
     *
     * @return callable[]
     */
    protected function getHook($name, $hook)
    {
        if (isset($this->hooks[$name][$hook])) {
            return $this->hooks[$name][$hook];
        }
        return [];
    }

    protected function callInteractor($interactor, $input, $output, AnnotationData $annotationData)
    {
        if ($interactor instanceof InteractorInterface) {
            return $interactor->interact($input, $output, $annotationData);
        }
        if (is_callable($interactor)) {
            return $interactor($input, $output, $annotationData);
        }
    }

    protected function callValidator($validator, $args, AnnotationData $annotationData)
    {
        // TODO: Adding AnnotationData to ValidatorInterface would be
        // a breaking change. Either hold off until 2.x, or make
        // a new interface containing a method that takes the extra parameter.
        if ($validator instanceof ValidatorInterface) {
            return $validator->validate($args);
        }
        if (is_callable($validator)) {
            return $validator($args, $annotationData);
        }
    }

    protected function callProcessor($processor, $result, $args, AnnotationData $annotationData)
    {
        $processed = null;
        // TODO: Adding AnnotationData to ProcessResultInterface would be
        // a breaking change. Either hold off until 2.x, or make
        // a new interface containing a method that takes the extra parameter.
        if ($processor instanceof ProcessResultInterface) {
            $processed = $processor->process($result, $args);
        }
        if (is_callable($processor)) {
            $processed = $processor($result, $args, $annotationData);
        }
        if (isset($processed)) {
            return $processed;
        }
        return $result;
    }

    protected function callDeterminer($determiner, $result)
    {
        if ($determiner instanceof StatusDeterminerInterface) {
            return $determiner->determineStatusCode($result);
        }
        if (is_callable($determiner)) {
            return $determiner($result);
        }
    }

    protected function callExtractor($extractor, $result)
    {
        if ($extractor instanceof ExtractOutputInterface) {
            return $extractor->extractOutput($result);
        }
        if (is_callable($extractor)) {
            return $extractor($result);
        }
    }

    /**
     * @param ConsoleCommandEvent $event
     */
    public function callCommandEventHooks(ConsoleCommandEvent $event)
    {
        /* @var Command $command */
        $command = $event->getCommand();
        $names = [$command->getName()];
        $commandEventHooks = $this->getCommandEvents($names);
        foreach ($commandEventHooks as $commandEvent) {
            if (is_callable($commandEvent)) {
                $commandEvent($event);
            }
        }
    }

    /**
     * @{@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [ConsoleEvents::COMMAND => 'callCommandEventHooks'];
    }
}


1		<?php
2		namespace Consolidation\AnnotatedCommand\Hooks;
3
4		use Symfony\Component\Console\Command\Command;
5		use Symfony\Component\Console\Input\InputInterface;
6		use Symfony\Component\Console\Output\OutputInterface;
7
8		use Symfony\Component\Console\ConsoleEvents;
9		use Symfony\Component\Console\Event\ConsoleCommandEvent;
10		use Symfony\Component\EventDispatcher\EventSubscriberInterface;
11
12		use Consolidation\AnnotatedCommand\ExitCodeInterface;
13		use Consolidation\AnnotatedCommand\OutputDataInterface;
14		use Consolidation\AnnotatedCommand\AnnotationData;
15
16		/**
17		* Manage named callback hooks
18		*/
19		class HookManager implements EventSubscriberInterface
20		{
21		protected $hooks = [];
22
23		const PRE_INTERACT = 'pre-interact';
24		const INTERACT = 'interact';
25		const POST_INTERACT = 'post-interact';
26		const PRE_COMMAND_EVENT = 'pre-command';
27		const COMMAND_EVENT = 'command';
28		const POST_COMMAND_EVENT = 'post-command';
29		const PRE_ARGUMENT_VALIDATOR = 'pre-validate';
30		const ARGUMENT_VALIDATOR = 'validate';
31		const POST_ARGUMENT_VALIDATOR = 'post-validate';
32		const PRE_PROCESS_RESULT = 'pre-process';
33		const PROCESS_RESULT = 'process';
34		const POST_PROCESS_RESULT = 'post-process';
35		const PRE_ALTER_RESULT = 'pre-alter';
36		const ALTER_RESULT = 'alter';
37		const POST_ALTER_RESULT = 'post-alter';
38		const STATUS_DETERMINER = 'status';
39		const EXTRACT_OUTPUT = 'extract';
40
41		public function __construct()
42		{
43		}
44
45		/**
46		* Add a hook
47		*
48		* @param mixed $callback The callback function to call
49		* @param string $hook The name of the hook to add
50		* @param string $name The name of the command to hook
51		* ('*' for all)
52		*/
53		public function add(callable $callback, $hook, $name = '*')
54		{
55		$this->hooks[$name][$hook][] = $callback;
56		}
57
58		/**
59		* Add an interact hook
60		*
61		* @param type ValidatorInterface $validator
62		* @param type $name The name of the command to hook
63		* ('*' for all)
64		*/
65		public function addInteractor(InteractorInterface $interactor, $name = '*')
66		{
67		$this->hooks[$name][self::INTERACT][] = $interactor;
68		}
69
70		/**
71		* Add a pre-validator hook
72		*
73		* @param type ValidatorInterface $validator
74		* @param type $name The name of the command to hook
75		* ('*' for all)
76		*/
77		public function addPreValidator(ValidatorInterface $validator, $name = '*')
78		{
79		$this->hooks[$name][self::PRE_ARGUMENT_VALIDATOR][] = $validator;
80		}
81
82		/**
83		* Add a validator hook
84		*
85		* @param type ValidatorInterface $validator
86		* @param type $name The name of the command to hook
87		* ('*' for all)
88		*/
89		public function addValidator(ValidatorInterface $validator, $name = '*')
90		{
91		$this->hooks[$name][self::ARGUMENT_VALIDATOR][] = $validator;
92		}
93
94		/**
95		* Add a result processor.
96		*
97		* @param type ProcessResultInterface $resultProcessor
98		* @param type $name The name of the command to hook
99		* ('*' for all)
100		*/
101		public function addResultProcessor(ProcessResultInterface $resultProcessor, $name = '*')
102		{
103		$this->hooks[$name][self::PROCESS_RESULT][] = $resultProcessor;
104		}
105
106		/**
107		* Add a result alterer. After a result is processed
108		* by a result processor, an alter hook may be used
109		* to convert the result from one form to another.
110		*
111		* @param type AlterResultInterface $resultAlterer
112		* @param type $name The name of the command to hook
113		* ('*' for all)
114		*/
115		public function addAlterResult(AlterResultInterface $resultAlterer, $name = '*')
116		{
117		$this->hooks[$name][self::ALTER_RESULT][] = $resultAlterer;
118		}
119
120		/**
121		* Add a status determiner. Usually, a command should return
122		* an integer on error, or a result object on success (which
123		* implies a status code of zero). If a result contains the
124		* status code in some other field, then a status determiner
125		* can be used to call the appropriate accessor method to
126		* determine the status code. This is usually not necessary,
127		* though; a command that fails may return a CommandError
128		* object, which contains a status code and a result message
129		* to display.
130		* @see CommandError::getExitCode()
131		*
132		* @param type StatusDeterminerInterface $statusDeterminer
133		* @param type $name The name of the command to hook
134		* ('*' for all)
135		*/
136		public function addStatusDeterminer(StatusDeterminerInterface $statusDeterminer, $name = '*')
137		{
138		$this->hooks[$name][self::STATUS_DETERMINER][] = $statusDeterminer;
139		}
140
141		/**
142		* Add an output extractor. If a command returns an object
143		* object, by default it is passed directly to the output
144		* formatter (if in use) for rendering. If the result object
145		* contains more information than just the data to render, though,
146		* then an output extractor can be used to call the appopriate
147		* accessor method of the result object to get the data to
148		* rendered. This is usually not necessary, though; it is preferable
149		* to have complex result objects implement the OutputDataInterface.
150		* @see OutputDataInterface::getOutputData()
151		*
152		* @param type ExtractOutputInterface $outputExtractor
153		* @param type $name The name of the command to hook
154		* ('*' for all)
155		*/
156		public function addOutputExtractor(ExtractOutputInterface $outputExtractor, $name = '*')
157		{
158		$this->hooks[$name][self::EXTRACT_OUTPUT][] = $outputExtractor;
159		}
160
161		public function interact(
162		InputInterface $input,
163		OutputInterface $output,
164		$names,
165		AnnotationData $annotationData
166		) {
167		$interactors = $this->getInteractors($names, $annotationData);
168		foreach ($interactors as $interactor) {
169		$this->callInteractor($interactor, $input, $output, $annotationData);
170		}
171		}
172
173	View Code Duplication	public function validateArguments($names, $args, AnnotationData $annotationData)
		0 ignored issues – show Duplication introduced 2016-09-13 18:53 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
174		{
175		$validators = $this->getValidators($names, $annotationData);
176		foreach ($validators as $validator) {
177		$validated = $this->callValidator($validator, $args, $annotationData);
178		if (is_object($validated)) {
179		return $validated;
180		}
181		if (is_array($validated)) {
182		$args = $validated;
183		}
184		}
185		return $args;
186		}
187
188		/**
189		* Process result and decide what to do with it.
190		* Allow client to add transformation / interpretation
191		* callbacks.
192		*/
193		public function alterResult($names, $result, $args, AnnotationData $annotationData)
194		{
195		$processors = $this->getProcessResultHooks($names, $annotationData);
196		foreach ($processors as $processor) {
197		$result = $this->callProcessor($processor, $result, $args, $annotationData);
198		}
199		$alterers = $this->getAlterResultHooks($names, $annotationData);
200		foreach ($alterers as $alterer) {
201		$result = $this->callProcessor($alterer, $result, $args, $annotationData);
202		}
203
204		return $result;
205		}
206
207		/**
208		* Call all status determiners, and see if any of them
209		* know how to convert to a status code.
210		*/
211		public function determineStatusCode($names, $result)
212		{
213		// If the result (post-processing) is an object that
214		// implements ExitCodeInterface, then we will ask it
215		// to give us the status code.
216		if ($result instanceof ExitCodeInterface) {
217		return $result->getExitCode();
218		}
219
220		// If the result does not implement ExitCodeInterface,
221		// then we'll see if there is a determiner that can
222		// extract a status code from the result.
223		$determiners = $this->getStatusDeterminers($names);
224		foreach ($determiners as $determiner) {
225		$status = $this->callDeterminer($determiner, $result);
226		if (isset($status)) {
227		return $status;
228		}
229		}
230		}
231
232		/**
233		* Convert the result object to printable output in
234		* structured form.
235		*/
236		public function extractOutput($names, $result)
237		{
238		if ($result instanceof OutputDataInterface) {
239		return $result->getOutputData();
240		}
241
242		$extractors = $this->getOutputExtractors($names);
243		foreach ($extractors as $extractor) {
244		$structuredOutput = $this->callExtractor($extractor, $result);
245		if (isset($structuredOutput)) {
246		return $structuredOutput;
247		}
248		}
249
250		return $result;
251		}
252
253		protected function getInteractors($names, AnnotationData $annotationData)
254		{
255		return $this->getHooks($names, self::INTERACT, $annotationData);
256		}
257
258		protected function getValidators($names, AnnotationData $annotationData)
259		{
260		return $this->getHooks($names, self::ARGUMENT_VALIDATOR, $annotationData);
261		}
262
263		protected function getStatusDeterminers($names)
264		{
265		return $this->getHooks($names, self::STATUS_DETERMINER);
266		}
267
268		protected function getProcessResultHooks($names, AnnotationData $annotationData)
269		{
270		return $this->getHooks($names, self::PROCESS_RESULT, $annotationData);
271		}
272
273		protected function getAlterResultHooks($names, AnnotationData $annotationData)
274		{
275		return $this->getHooks($names, self::ALTER_RESULT, $annotationData);
276		}
277
278		protected function getOutputExtractors($names)
279		{
280		return $this->getHooks($names, self::EXTRACT_OUTPUT);
281		}
282
283		protected function getCommandEvents($names)
284		{
285		return $this->getHooks($names, self::COMMAND_EVENT);
286		}
287
288		/**
289		* Get a set of hooks with the provided name(s). Include the
290		* pre- and post- hooks, and also include the global hooks ('*')
291		* in addition to the named hooks provided.
292		*
293		* @param string\|array $names The name of the function being hooked.
294		* @param string $hook The specific hook name (e.g. alter)
295		*
296		* @return callable[]
297		*/
298		protected function getHooks($names, $hook, $annotationData = null)
299		{
300		$names = array_merge(
301		(array)$names,
302		($annotationData == null) ? [] : array_map(function ($item) {
303		return "@$item";
304		}, $annotationData->keys())
305		);
306		$names[] = '*';
307		return array_merge(
308		$this->get($names, "pre-$hook"),
309		$this->get($names, $hook),
310		$this->get($names, "post-$hook")
311		);
312		}
313
314		/**
315		* Get a set of hooks with the provided name(s).
316		*
317		* @param string\|array $names The name of the function being hooked.
318		* @param string $hook The specific hook name (e.g. alter)
319		*
320		* @return callable[]
321		*/
322		public function get($names, $hook)
323		{
324		$hooks = [];
325		foreach ((array)$names as $name) {
326		$hooks = array_merge($hooks, $this->getHook($name, $hook));
327		}
328		return $hooks;
329		}
330
331		/**
332		* Get a single named hook.
333		*
334		* @param string $name The name of the hooked method
335		* @param string $hook The specific hook name (e.g. alter)
336		*
337		* @return callable[]
338		*/
339		protected function getHook($name, $hook)
340		{
341		if (isset($this->hooks[$name][$hook])) {
342		return $this->hooks[$name][$hook];
343		}
344		return [];
345		}
346
347		protected function callInteractor($interactor, $input, $output, AnnotationData $annotationData)
348		{
349		if ($interactor instanceof InteractorInterface) {
350		return $interactor->interact($input, $output, $annotationData);
351		}
352		if (is_callable($interactor)) {
353		return $interactor($input, $output, $annotationData);
354		}
355		}
356
357		protected function callValidator($validator, $args, AnnotationData $annotationData)
358		{
359		// TODO: Adding AnnotationData to ValidatorInterface would be
360		// a breaking change. Either hold off until 2.x, or make
361		// a new interface containing a method that takes the extra parameter.
362		if ($validator instanceof ValidatorInterface) {
363		return $validator->validate($args);
364		}
365		if (is_callable($validator)) {
366		return $validator($args, $annotationData);
367		}
368		}
369
370		protected function callProcessor($processor, $result, $args, AnnotationData $annotationData)
371		{
372		$processed = null;
373		// TODO: Adding AnnotationData to ProcessResultInterface would be
374		// a breaking change. Either hold off until 2.x, or make
375		// a new interface containing a method that takes the extra parameter.
376		if ($processor instanceof ProcessResultInterface) {
377		$processed = $processor->process($result, $args);
378		}
379		if (is_callable($processor)) {
380		$processed = $processor($result, $args, $annotationData);
381		}
382		if (isset($processed)) {
383		return $processed;
384		}
385		return $result;
386		}
387
388		protected function callDeterminer($determiner, $result)
389		{
390		if ($determiner instanceof StatusDeterminerInterface) {
391		return $determiner->determineStatusCode($result);
392		}
393		if (is_callable($determiner)) {
394		return $determiner($result);
395		}
396		}
397
398		protected function callExtractor($extractor, $result)
399		{
400		if ($extractor instanceof ExtractOutputInterface) {
401		return $extractor->extractOutput($result);
402		}
403		if (is_callable($extractor)) {
404		return $extractor($result);
405		}
406		}
407
408		/**
409		* @param ConsoleCommandEvent $event
410		*/
411		public function callCommandEventHooks(ConsoleCommandEvent $event)
412		{
413		/* @var Command $command */
414		$command = $event->getCommand();
415		$names = [$command->getName()];
416		$commandEventHooks = $this->getCommandEvents($names);
417		foreach ($commandEventHooks as $commandEvent) {
418		if (is_callable($commandEvent)) {
419		$commandEvent($event);
420		}
421		}
422		}
423
424		/**
425		* @{@inheritdoc}
426		*/
427		public static function getSubscribedEvents()
428		{
429		return [ConsoleEvents::COMMAND => 'callCommandEventHooks'];
430		}
431		}
432

consolidation / annotated-command

Push — master ( 303d3b...22ea3e )

HookManager::addPreValidator() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like