HookManager::add() - Code Metrics - Inspection of "Adding replace-command hook." - consolidation/annotated-command - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#97)

unknown

created 2017-03-22 17:09 UTC

HookManager::add() A

↳ Parent: HookManager

Complexity

Conditions	2
Paths	2

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	8
rs	9.4285
cc	2
eloc	5
nc	2
nop	3

<?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;
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;
    }

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

consolidation / annotated-command

Pull Request — master (#97)

HookManager::add() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like