HookManager::addPostCommandHook() - Code Metrics - consolidation/annotated-command - Measure and Improve Code Quality continuously with Scrutinizer

HookManager::addPostCommandHook() A
last analyzed 2020-08-10 23:41 UTC

↳ Parent: HookManager

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	5
rs	10
c	0
b	0
f	0
cc	1
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 Symfony\Component\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\EventDispatcher\EventDispatcher;

use Consolidation\AnnotatedCommand\ExitCodeInterface;
use Consolidation\AnnotatedCommand\OutputDataInterface;
use Consolidation\AnnotatedCommand\AnnotationData;
use Consolidation\AnnotatedCommand\CommandData;
use Consolidation\AnnotatedCommand\CommandError;
use Consolidation\AnnotatedCommand\Hooks\Dispatchers\CommandEventHookDispatcher;

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

    const REPLACE_COMMAND_HOOK = 'replace-command';
    const PRE_COMMAND_EVENT = 'pre-command-event';
    const COMMAND_EVENT = 'command-event';
    const POST_COMMAND_EVENT = 'post-command-event';
    const PRE_OPTION_HOOK = 'pre-option';
    const OPTION_HOOK = 'option';
    const POST_OPTION_HOOK = 'post-option';
    const PRE_INITIALIZE = 'pre-init';
    const INITIALIZE = 'init';
    const POST_INITIALIZE = 'post-init';
    const PRE_INTERACT = 'pre-interact';
    const INTERACT = 'interact';
    const POST_INTERACT = 'post-interact';
    const PRE_ARGUMENT_VALIDATOR = 'pre-validate';
    const ARGUMENT_VALIDATOR = 'validate';
    const POST_ARGUMENT_VALIDATOR = 'post-validate';
    const PRE_COMMAND_HOOK = 'pre-command';
    const COMMAND_HOOK = 'command';
    const POST_COMMAND_HOOK = 'post-command';
    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';
    const ON_EVENT = 'on-event';

    public function __construct()
    {
    }

    public function getAllHooks()
    {
        return $this->hooks;
    }

    /**
     * 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 = '*')
    {
        if (empty($name)) {
            $name = static::getClassNameFromCallback($callback);
        }
        $this->hooks[$name][$hook][] = $callback;
        return $this;
    }

    public function recordHookOptions($commandInfo, $name)
    {
        $this->hookOptions[$name][] = $commandInfo;
        return $this;
    }

    public static function getNames($command, $callback)
    {
        return array_filter(
            array_merge(
                static::getNamesUsingCommands($command),
                [static::getClassNameFromCallback($callback)]
            )
        );
    }

    protected static function getNamesUsingCommands($command)
    {
        return array_merge(
            [$command->getName()],
            $command->getAliases()
        );
    }

    /**
     * If a command hook does not specify any particular command
     * name that it should be attached to, then it will be applied
     * to every command that is defined in the same class as the hook.
     * This is controlled by using the namespace + class name of
     * the implementing class of the callback hook.
     */
    protected static function getClassNameFromCallback($callback)
    {
        if (!is_array($callback)) {
            return '';
        }
        $reflectionClass = new \ReflectionClass($callback[0]);
        return $reflectionClass->getName();

    }

    /**
     * Add a replace command hook
     *
     * @param type ReplaceCommandHookInterface $provider
     * @param type string $command_name The name of the command to replace
     */
    public function addReplaceCommandHook(ReplaceCommandHookInterface $replaceCommandHook, $name)
    {
        $this->hooks[$name][self::REPLACE_COMMAND_HOOK][] = $replaceCommandHook;
        return $this;
    }

    public function addPreCommandEventDispatcher(EventDispatcherInterface $eventDispatcher, $name = '*')
    {
        $this->hooks[$name][self::PRE_COMMAND_EVENT][] = $eventDispatcher;
        return $this;
    }

    public function addCommandEventDispatcher(EventDispatcherInterface $eventDispatcher, $name = '*')
    {
        $this->hooks[$name][self::COMMAND_EVENT][] = $eventDispatcher;
        return $this;
    }

    public function addPostCommandEventDispatcher(EventDispatcherInterface $eventDispatcher, $name = '*')
    {
        $this->hooks[$name][self::POST_COMMAND_EVENT][] = $eventDispatcher;
        return $this;
    }

    public function addCommandEvent(EventSubscriberInterface $eventSubscriber)
    {
        // Wrap the event subscriber in a dispatcher and add it
        $dispatcher = new EventDispatcher();
        $dispatcher->addSubscriber($eventSubscriber);
        return $this->addCommandEventDispatcher($dispatcher);
    }

    /**
     * Add an configuration provider hook
     *
     * @param type InitializeHookInterface $provider
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addInitializeHook(InitializeHookInterface $initializeHook, $name = '*')
    {
        $this->hooks[$name][self::INITIALIZE][] = $initializeHook;
        return $this;
    }

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

    /**
     * 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;
        return $this;
    }

    /**
     * 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;
        return $this;
    }

    /**
     * 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;
        return $this;
    }

    /**
     * Add a pre-command hook.  This is the same as a validator hook, except
     * that it will run after all of the post-validator hooks.
     *
     * @param type ValidatorInterface $preCommand
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addPreCommandHook(ValidatorInterface $preCommand, $name = '*')
    {
        $this->hooks[$name][self::PRE_COMMAND_HOOK][] = $preCommand;
        return $this;
    }

    /**
     * Add a post-command hook.  This is the same as a pre-process hook,
     * except that it will run before the first pre-process hook.
     *
     * @param type ProcessResultInterface $postCommand
     * @param type $name The name of the command to hook
     *   ('*' for all)
     */
    public function addPostCommandHook(ProcessResultInterface $postCommand, $name = '*')
    {
        $this->hooks[$name][self::POST_COMMAND_HOOK][] = $postCommand;
        return $this;
    }

    /**
     * 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;
        return $this;
    }

    /**
     * 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;
        return $this;
    }

    /**
     * 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;
        return $this;
    }

    /**
     * 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;
        return $this;
    }

    public function getHookOptionsForCommand($command)
    {
        $names = $this->addWildcardHooksToNames($command->getNames(), $command->getAnnotationData());
        return $this->getHookOptions($names);
    }

    /**
     * @return CommandInfo[]
     */
    public function getHookOptions($names)
    {
        $result = [];
        foreach ($names as $name) {
            if (isset($this->hookOptions[$name])) {
                $result = array_merge($result, $this->hookOptions[$name]);
            }
        }
        return $result;
    }

    /**
     * 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[] $hooks A list of hooks (e.g. [HookManager::ALTER_RESULT])
     *
     * @return callable[]
     */
    public function getHooks($names, $hooks, $annotationData = null)
    {
        return $this->get($this->addWildcardHooksToNames($names, $annotationData), $hooks);
    }

    protected function addWildcardHooksToNames($names, $annotationData = null)
    {
        $names = array_merge(
            (array)$names,
            ($annotationData == null) ? [] : array_map(function ($item) {
                return "@$item";
            }, $annotationData->keys())
        );
        $names[] = '*';
        return array_unique($names);
    }

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

    /**
     * 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[]
     */
    public function getHook($name, $hook)
    {
        if (isset($this->hooks[$name][$hook])) {
            return $this->hooks[$name][$hook];
        }
        return [];
    }

    /**
     * Call the command event hooks.
     *
     * TODO: This should be moved to CommandEventHookDispatcher, which
     * should become the class that implements EventSubscriberInterface.
     * This change would break all clients, though, so postpone until next
     * major release.
     *
     * @param ConsoleCommandEvent $event
     */
    public function callCommandEventHooks(ConsoleCommandEvent $event)
    {
        /* @var Command $command */
        $command = $event->getCommand();
        $dispatcher = new CommandEventHookDispatcher($this, [$command->getName()]);
        $dispatcher->callCommandEventHooks($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			use Symfony\Component\EventDispatcher\EventDispatcherInterface;
12			use Symfony\Component\EventDispatcher\EventDispatcher;
13
14			use Consolidation\AnnotatedCommand\ExitCodeInterface;
15			use Consolidation\AnnotatedCommand\OutputDataInterface;
16			use Consolidation\AnnotatedCommand\AnnotationData;
17			use Consolidation\AnnotatedCommand\CommandData;
18			use Consolidation\AnnotatedCommand\CommandError;
19			use Consolidation\AnnotatedCommand\Hooks\Dispatchers\CommandEventHookDispatcher;
20
21			/**
22			* Manage named callback hooks
23			*/
24			class HookManager implements EventSubscriberInterface
25			{
26			protected $hooks = [];
27			/** var CommandInfo[] */
28			protected $hookOptions = [];
29
30			const REPLACE_COMMAND_HOOK = 'replace-command';
31			const PRE_COMMAND_EVENT = 'pre-command-event';
32			const COMMAND_EVENT = 'command-event';
33			const POST_COMMAND_EVENT = 'post-command-event';
34			const PRE_OPTION_HOOK = 'pre-option';
35			const OPTION_HOOK = 'option';
36			const POST_OPTION_HOOK = 'post-option';
37			const PRE_INITIALIZE = 'pre-init';
38			const INITIALIZE = 'init';
39			const POST_INITIALIZE = 'post-init';
40			const PRE_INTERACT = 'pre-interact';
41			const INTERACT = 'interact';
42			const POST_INTERACT = 'post-interact';
43			const PRE_ARGUMENT_VALIDATOR = 'pre-validate';
44			const ARGUMENT_VALIDATOR = 'validate';
45			const POST_ARGUMENT_VALIDATOR = 'post-validate';
46			const PRE_COMMAND_HOOK = 'pre-command';
47			const COMMAND_HOOK = 'command';
48			const POST_COMMAND_HOOK = 'post-command';
49			const PRE_PROCESS_RESULT = 'pre-process';
50			const PROCESS_RESULT = 'process';
51			const POST_PROCESS_RESULT = 'post-process';
52			const PRE_ALTER_RESULT = 'pre-alter';
53			const ALTER_RESULT = 'alter';
54			const POST_ALTER_RESULT = 'post-alter';
55			const STATUS_DETERMINER = 'status';
56			const EXTRACT_OUTPUT = 'extract';
57			const ON_EVENT = 'on-event';
58
59			public function __construct()
60			{
61			}
62
63			public function getAllHooks()
64			{
65			return $this->hooks;
66			}
67
68			/**
69			* Add a hook
70			*
71			* @param mixed $callback The callback function to call
72			* @param string $hook The name of the hook to add
73			* @param string $name The name of the command to hook
74			* ('*' for all)
75			*/
76			public function add(callable $callback, $hook, $name = '*')
77			{
78			if (empty($name)) {
79			$name = static::getClassNameFromCallback($callback);
80			}
81			$this->hooks[$name][$hook][] = $callback;
82			return $this;
83			}
84
85			public function recordHookOptions($commandInfo, $name)
86			{
87			$this->hookOptions[$name][] = $commandInfo;
88			return $this;
89			}
90
91			public static function getNames($command, $callback)
92			{
93			return array_filter(
94			array_merge(
95			static::getNamesUsingCommands($command),
96			[static::getClassNameFromCallback($callback)]
97			)
98			);
99			}
100
101			protected static function getNamesUsingCommands($command)
102			{
103			return array_merge(
104			[$command->getName()],
105			$command->getAliases()
106			);
107			}
108
109			/**
110			* If a command hook does not specify any particular command
111			* name that it should be attached to, then it will be applied
112			* to every command that is defined in the same class as the hook.
113			* This is controlled by using the namespace + class name of
114			* the implementing class of the callback hook.
115			*/
116			protected static function getClassNameFromCallback($callback)
117			{
118			if (!is_array($callback)) {
119			return '';
120			}
121			$reflectionClass = new \ReflectionClass($callback[0]);
122			return $reflectionClass->getName();
			0 ignored issues – show Bug introduced 2019-08-15 13:26 UTC by Report Bug Copy Issue Report Consider using `$reflectionClass->name`. There is an issue with `getName()` and APC-enabled PHP versions. Loading history...
123			}
124
125			/**
126			* Add a replace command hook
127			*
128			* @param type ReplaceCommandHookInterface $provider
129			* @param type string $command_name The name of the command to replace
130			*/
131			public function addReplaceCommandHook(ReplaceCommandHookInterface $replaceCommandHook, $name)
132			{
133			$this->hooks[$name][self::REPLACE_COMMAND_HOOK][] = $replaceCommandHook;
134			return $this;
135			}
136
137			public function addPreCommandEventDispatcher(EventDispatcherInterface $eventDispatcher, $name = '*')
138			{
139			$this->hooks[$name][self::PRE_COMMAND_EVENT][] = $eventDispatcher;
140			return $this;
141			}
142
143			public function addCommandEventDispatcher(EventDispatcherInterface $eventDispatcher, $name = '*')
144			{
145			$this->hooks[$name][self::COMMAND_EVENT][] = $eventDispatcher;
146			return $this;
147			}
148
149			public function addPostCommandEventDispatcher(EventDispatcherInterface $eventDispatcher, $name = '*')
150			{
151			$this->hooks[$name][self::POST_COMMAND_EVENT][] = $eventDispatcher;
152			return $this;
153			}
154
155			public function addCommandEvent(EventSubscriberInterface $eventSubscriber)
156			{
157			// Wrap the event subscriber in a dispatcher and add it
158			$dispatcher = new EventDispatcher();
159			$dispatcher->addSubscriber($eventSubscriber);
160			return $this->addCommandEventDispatcher($dispatcher);
161			}
162
163			/**
164			* Add an configuration provider hook
165			*
166			* @param type InitializeHookInterface $provider
167			* @param type $name The name of the command to hook
168			* ('*' for all)
169			*/
170			public function addInitializeHook(InitializeHookInterface $initializeHook, $name = '*')
171			{
172			$this->hooks[$name][self::INITIALIZE][] = $initializeHook;
173			return $this;
174			}
175
176			/**
177			* Add an option hook
178			*
179			* @param type ValidatorInterface $validator
180			* @param type $name The name of the command to hook
181			* ('*' for all)
182			*/
183			public function addOptionHook(OptionHookInterface $interactor, $name = '*')
184			{
185			$this->hooks[$name][self::INTERACT][] = $interactor;
186			return $this;
187			}
188
189			/**
190			* Add an interact hook
191			*
192			* @param type ValidatorInterface $validator
193			* @param type $name The name of the command to hook
194			* ('*' for all)
195			*/
196			public function addInteractor(InteractorInterface $interactor, $name = '*')
197			{
198			$this->hooks[$name][self::INTERACT][] = $interactor;
199			return $this;
200			}
201
202			/**
203			* Add a pre-validator hook
204			*
205			* @param type ValidatorInterface $validator
206			* @param type $name The name of the command to hook
207			* ('*' for all)
208			*/
209			public function addPreValidator(ValidatorInterface $validator, $name = '*')
210			{
211			$this->hooks[$name][self::PRE_ARGUMENT_VALIDATOR][] = $validator;
212			return $this;
213			}
214
215			/**
216			* Add a validator hook
217			*
218			* @param type ValidatorInterface $validator
219			* @param type $name The name of the command to hook
220			* ('*' for all)
221			*/
222			public function addValidator(ValidatorInterface $validator, $name = '*')
223			{
224			$this->hooks[$name][self::ARGUMENT_VALIDATOR][] = $validator;
225			return $this;
226			}
227
228			/**
229			* Add a pre-command hook. This is the same as a validator hook, except
230			* that it will run after all of the post-validator hooks.
231			*
232			* @param type ValidatorInterface $preCommand
233			* @param type $name The name of the command to hook
234			* ('*' for all)
235			*/
236			public function addPreCommandHook(ValidatorInterface $preCommand, $name = '*')
237			{
238			$this->hooks[$name][self::PRE_COMMAND_HOOK][] = $preCommand;
239			return $this;
240			}
241
242			/**
243			* Add a post-command hook. This is the same as a pre-process hook,
244			* except that it will run before the first pre-process hook.
245			*
246			* @param type ProcessResultInterface $postCommand
247			* @param type $name The name of the command to hook
248			* ('*' for all)
249			*/
250			public function addPostCommandHook(ProcessResultInterface $postCommand, $name = '*')
251			{
252			$this->hooks[$name][self::POST_COMMAND_HOOK][] = $postCommand;
253			return $this;
254			}
255
256			/**
257			* Add a result processor.
258			*
259			* @param type ProcessResultInterface $resultProcessor
260			* @param type $name The name of the command to hook
261			* ('*' for all)
262			*/
263			public function addResultProcessor(ProcessResultInterface $resultProcessor, $name = '*')
264			{
265			$this->hooks[$name][self::PROCESS_RESULT][] = $resultProcessor;
266			return $this;
267			}
268
269			/**
270			* Add a result alterer. After a result is processed
271			* by a result processor, an alter hook may be used
272			* to convert the result from one form to another.
273			*
274			* @param type AlterResultInterface $resultAlterer
275			* @param type $name The name of the command to hook
276			* ('*' for all)
277			*/
278			public function addAlterResult(AlterResultInterface $resultAlterer, $name = '*')
279			{
280			$this->hooks[$name][self::ALTER_RESULT][] = $resultAlterer;
281			return $this;
282			}
283
284			/**
285			* Add a status determiner. Usually, a command should return
286			* an integer on error, or a result object on success (which
287			* implies a status code of zero). If a result contains the
288			* status code in some other field, then a status determiner
289			* can be used to call the appropriate accessor method to
290			* determine the status code. This is usually not necessary,
291			* though; a command that fails may return a CommandError
292			* object, which contains a status code and a result message
293			* to display.
294			* @see CommandError::getExitCode()
295			*
296			* @param type StatusDeterminerInterface $statusDeterminer
297			* @param type $name The name of the command to hook
298			* ('*' for all)
299			*/
300			public function addStatusDeterminer(StatusDeterminerInterface $statusDeterminer, $name = '*')
301			{
302			$this->hooks[$name][self::STATUS_DETERMINER][] = $statusDeterminer;
303			return $this;
304			}
305
306			/**
307			* Add an output extractor. If a command returns an object
308			* object, by default it is passed directly to the output
309			* formatter (if in use) for rendering. If the result object
310			* contains more information than just the data to render, though,
311			* then an output extractor can be used to call the appopriate
312			* accessor method of the result object to get the data to
313			* rendered. This is usually not necessary, though; it is preferable
314			* to have complex result objects implement the OutputDataInterface.
315			* @see OutputDataInterface::getOutputData()
316			*
317			* @param type ExtractOutputInterface $outputExtractor
318			* @param type $name The name of the command to hook
319			* ('*' for all)
320			*/
321			public function addOutputExtractor(ExtractOutputInterface $outputExtractor, $name = '*')
322			{
323			$this->hooks[$name][self::EXTRACT_OUTPUT][] = $outputExtractor;
324			return $this;
325			}
326
327			public function getHookOptionsForCommand($command)
328			{
329			$names = $this->addWildcardHooksToNames($command->getNames(), $command->getAnnotationData());
330			return $this->getHookOptions($names);
331			}
332
333			/**
334			* @return CommandInfo[]
335			*/
336			public function getHookOptions($names)
337			{
338			$result = [];
339			foreach ($names as $name) {
340			if (isset($this->hookOptions[$name])) {
341			$result = array_merge($result, $this->hookOptions[$name]);
342			}
343			}
344			return $result;
345			}
346
347			/**
348			* Get a set of hooks with the provided name(s). Include the
349			* pre- and post- hooks, and also include the global hooks ('*')
350			* in addition to the named hooks provided.
351			*
352			* @param string\|array $names The name of the function being hooked.
353			* @param string[] $hooks A list of hooks (e.g. [HookManager::ALTER_RESULT])
354			*
355			* @return callable[]
356			*/
357			public function getHooks($names, $hooks, $annotationData = null)
358			{
359			return $this->get($this->addWildcardHooksToNames($names, $annotationData), $hooks);
360			}
361
362			protected function addWildcardHooksToNames($names, $annotationData = null)
363			{
364			$names = array_merge(
365			(array)$names,
366			($annotationData == null) ? [] : array_map(function ($item) {
367			return "@$item";
368			}, $annotationData->keys())
369			);
370			$names[] = '*';
371			return array_unique($names);
372			}
373
374			/**
375			* Get a set of hooks with the provided name(s).
376			*
377			* @param string\|array $names The name of the function being hooked.
378			* @param string[] $hooks The list of hook names (e.g. [HookManager::ALTER_RESULT])
379			*
380			* @return callable[]
381			*/
382			public function get($names, $hooks)
383			{
384			$result = [];
385			foreach ((array)$hooks as $hook) {
386			foreach ((array)$names as $name) {
387			$result = array_merge($result, $this->getHook($name, $hook));
388			}
389			}
390			return $result;
391			}
392
393			/**
394			* Get a single named hook.
395			*
396			* @param string $name The name of the hooked method
397			* @param string $hook The specific hook name (e.g. alter)
398			*
399			* @return callable[]
400			*/
401			public function getHook($name, $hook)
402			{
403			if (isset($this->hooks[$name][$hook])) {
404			return $this->hooks[$name][$hook];
405			}
406			return [];
407			}
408
409			/**
410			* Call the command event hooks.
411			*
412			* TODO: This should be moved to CommandEventHookDispatcher, which
413			* should become the class that implements EventSubscriberInterface.
414			* This change would break all clients, though, so postpone until next
415			* major release.
416			*
417			* @param ConsoleCommandEvent $event
418			*/
419			public function callCommandEventHooks(ConsoleCommandEvent $event)
420			{
421			/* @var Command $command */
422			$command = $event->getCommand();
423			$dispatcher = new CommandEventHookDispatcher($this, [$command->getName()]);
424			$dispatcher->callCommandEventHooks($event);
425			}
426
427			/**
428			* @{@inheritdoc}
429			*/
430			public static function getSubscribedEvents()
431			{
432			return [ConsoleEvents::COMMAND => 'callCommandEventHooks'];
433			}
434			}
435

consolidation / annotated-command

HookManager::addPostCommandHook() A last analyzed 2020-08-10 23:41 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

HookManager::addPostCommandHook() A
last analyzed 2020-08-10 23:41 UTC