eventespresso / event-espresso-core

core/services/commands/CommandHandlerManager.php

Indentation +100 added lines, -100 removed lines

@@ -18,83 +18,83 @@ 
 class CommandHandlerManager implements CommandHandlerManagerInterface
 {
 
-    /**
-     * @var CommandHandlerInterface[] $command_handlers
-     */
-    protected $command_handlers;
+	/**
+	 * @var CommandHandlerInterface[] $command_handlers
+	 */
+	protected $command_handlers;
 
-    /**
-     * @type LoaderInterface $loader
-     */
-    private $loader;
+	/**
+	 * @type LoaderInterface $loader
+	 */
+	private $loader;
 
 
-    /**
-     * CommandHandlerManager constructor
-     *
-     * @param LoaderInterface $loader
-     */
-    public function __construct(LoaderInterface $loader)
-    {
-        $this->loader = $loader;
-    }
+	/**
+	 * CommandHandlerManager constructor
+	 *
+	 * @param LoaderInterface $loader
+	 */
+	public function __construct(LoaderInterface $loader)
+	{
+		$this->loader = $loader;
+	}
 
 
-    /**
-     * By default, Commands and CommandHandlers would normally
-     * reside in the same folder under the same namespace,
-     * and the names of the two classes would only differ in that
-     * one ends in "Command" and the other ends in "CommandHandler".
-     * However, if you wanted to utilize a CommandHandler from somewhere else,
-     * then this method allows you to add that CommandHandler and specify the FQCN
-     * (Fully Qualified ClassName) for the Command class that it should be used for.
-     * For example:
-     *      by default the "Vendor\some\namespace\DoSomethingCommand"
-     *      would resolve to using "Vendor\some\namespace\DoSomethingCommandHandler"
-     *      but if you wanted to instead process that commend using:
-     *      "Vendor\a\totally\different\namespace\for\DoSomethingCommandHandler"
-     *      then the following code:
-     *      $CommandHandlerManager = $this->loader->getShared( 'CommandHandlerManagerInterface' );
-     *      $CommandHandlerManager->addCommandHandler(
-     *          new Vendor\a\totally\different\namespace\for\DoSomethingCommandHandler(),
-     *          'Vendor\some\namespace\DoSomethingCommand'
-     *      );
-     *      would result in the alternate CommandHandler being used to process that Command
-     *
-     * !!! IMPORTANT !!!
-     * If overriding the default CommandHandler for a Command,
-     * be sure to also override CommandHandler::verify(),
-     * or else an Exception will be thrown when the CommandBus
-     * attempts to verify that the incoming Command matches the Handler
-     *
-     * @param CommandHandlerInterface $command_handler
-     * @param string                  $fqcn_for_command Fully Qualified ClassName for Command
-     * @return void
-     * @throws InvalidCommandHandlerException
-     */
-    public function addCommandHandler(CommandHandlerInterface $command_handler, $fqcn_for_command = '')
-    {
-        $command = ! empty($fqcn_for_command)
-            ? $fqcn_for_command
-            : str_replace('CommandHandler', 'Command', get_class($command_handler));
-        if (empty($command)) {
-            throw new InvalidCommandHandlerException($command);
-        }
-        $this->command_handlers[ $command ] = $command_handler;
-    }
+	/**
+	 * By default, Commands and CommandHandlers would normally
+	 * reside in the same folder under the same namespace,
+	 * and the names of the two classes would only differ in that
+	 * one ends in "Command" and the other ends in "CommandHandler".
+	 * However, if you wanted to utilize a CommandHandler from somewhere else,
+	 * then this method allows you to add that CommandHandler and specify the FQCN
+	 * (Fully Qualified ClassName) for the Command class that it should be used for.
+	 * For example:
+	 *      by default the "Vendor\some\namespace\DoSomethingCommand"
+	 *      would resolve to using "Vendor\some\namespace\DoSomethingCommandHandler"
+	 *      but if you wanted to instead process that commend using:
+	 *      "Vendor\a\totally\different\namespace\for\DoSomethingCommandHandler"
+	 *      then the following code:
+	 *      $CommandHandlerManager = $this->loader->getShared( 'CommandHandlerManagerInterface' );
+	 *      $CommandHandlerManager->addCommandHandler(
+	 *          new Vendor\a\totally\different\namespace\for\DoSomethingCommandHandler(),
+	 *          'Vendor\some\namespace\DoSomethingCommand'
+	 *      );
+	 *      would result in the alternate CommandHandler being used to process that Command
+	 *
+	 * !!! IMPORTANT !!!
+	 * If overriding the default CommandHandler for a Command,
+	 * be sure to also override CommandHandler::verify(),
+	 * or else an Exception will be thrown when the CommandBus
+	 * attempts to verify that the incoming Command matches the Handler
+	 *
+	 * @param CommandHandlerInterface $command_handler
+	 * @param string                  $fqcn_for_command Fully Qualified ClassName for Command
+	 * @return void
+	 * @throws InvalidCommandHandlerException
+	 */
+	public function addCommandHandler(CommandHandlerInterface $command_handler, $fqcn_for_command = '')
+	{
+		$command = ! empty($fqcn_for_command)
+			? $fqcn_for_command
+			: str_replace('CommandHandler', 'Command', get_class($command_handler));
+		if (empty($command)) {
+			throw new InvalidCommandHandlerException($command);
+		}
+		$this->command_handlers[ $command ] = $command_handler;
+	}
 
 
-    /**
-     * @param CommandInterface    $command
-     * @param CommandBusInterface $command_bus
-     * @return mixed
-     * @throws DomainException
-     * @throws CommandHandlerNotFoundException
-     */
-    public function getCommandHandler(CommandInterface $command, CommandBusInterface $command_bus = null)
-    {
-        $command_name = get_class($command);
-        /*
+	/**
+	 * @param CommandInterface    $command
+	 * @param CommandBusInterface $command_bus
+	 * @return mixed
+	 * @throws DomainException
+	 * @throws CommandHandlerNotFoundException
+	 */
+	public function getCommandHandler(CommandInterface $command, CommandBusInterface $command_bus = null)
+	{
+		$command_name = get_class($command);
+		/*
          * Filters the Fully Qualified Class Name for the Command Handler
          * that will be used to handle the incoming Command
          *
@@ -107,34 +107,34 @@ 
          * @param string "CommandHandler::class" Fully Qualified Class Name for the Command Handler
          * @param CommandInterface $command the actual Command instance
          */
-        $command_handler = apply_filters(
-            'FHEE__EventEspresso_core_services_commands_CommandHandlerManager__getCommandHandler__command_handler',
-            str_replace('Command', 'CommandHandler', $command_name),
-            $command
-        );
-        $handler = null;
-        // has a command handler already been set for this class ?
-        // if not, can we find one via the FQCN ?
-        if (isset($this->command_handlers[ $command_name ])) {
-            $handler = $this->command_handlers[ $command_name ];
-        } elseif (class_exists($command_handler)) {
-            $handler = $this->loader->getShared($command_handler);
-        }
-        // if Handler requires an instance of the CommandBus, but that has not yet been set
-        if ($handler instanceof CompositeCommandHandler && ! $handler->commandBus() instanceof CommandBusInterface) {
-            if (! $command_bus instanceof CommandBusInterface) {
-                throw new DomainException(
-                    esc_html__(
-                        'CompositeCommandHandler classes require an instance of the CommandBus.',
-                        'event_espresso'
-                    )
-                );
-            }
-            $handler->setCommandBus($command_bus);
-        }
-        if ($handler instanceof CommandHandlerInterface) {
-            return $handler;
-        }
-        throw new CommandHandlerNotFoundException($command_handler);
-    }
+		$command_handler = apply_filters(
+			'FHEE__EventEspresso_core_services_commands_CommandHandlerManager__getCommandHandler__command_handler',
+			str_replace('Command', 'CommandHandler', $command_name),
+			$command
+		);
+		$handler = null;
+		// has a command handler already been set for this class ?
+		// if not, can we find one via the FQCN ?
+		if (isset($this->command_handlers[ $command_name ])) {
+			$handler = $this->command_handlers[ $command_name ];
+		} elseif (class_exists($command_handler)) {
+			$handler = $this->loader->getShared($command_handler);
+		}
+		// if Handler requires an instance of the CommandBus, but that has not yet been set
+		if ($handler instanceof CompositeCommandHandler && ! $handler->commandBus() instanceof CommandBusInterface) {
+			if (! $command_bus instanceof CommandBusInterface) {
+				throw new DomainException(
+					esc_html__(
+						'CompositeCommandHandler classes require an instance of the CommandBus.',
+						'event_espresso'
+					)
+				);
+			}
+			$handler->setCommandBus($command_bus);
+		}
+		if ($handler instanceof CommandHandlerInterface) {
+			return $handler;
+		}
+		throw new CommandHandlerNotFoundException($command_handler);
+	}
 }

core/services/commands/CommandBus.php

Indentation +63 added lines, -63 removed lines

@@ -34,74 +34,74 @@
 class CommandBus implements CommandBusInterface
 {
 
-    /**
-     * @type CommandHandlerManagerInterface $command_handler_manager
-     */
-    private $command_handler_manager;
+	/**
+	 * @type CommandHandlerManagerInterface $command_handler_manager
+	 */
+	private $command_handler_manager;
 
-    /**
-     * @type CommandBusMiddlewareInterface[] $command_bus_middleware
-     */
-    private $command_bus_middleware;
+	/**
+	 * @type CommandBusMiddlewareInterface[] $command_bus_middleware
+	 */
+	private $command_bus_middleware;
 
 
-    /**
-     * CommandBus constructor
-     *
-     * @param CommandHandlerManagerInterface  $command_handler_manager
-     * @param CommandBusMiddlewareInterface[] $command_bus_middleware
-     */
-    public function __construct(
-        CommandHandlerManagerInterface $command_handler_manager,
-        array $command_bus_middleware = array()
-    ) {
-        $this->command_handler_manager = $command_handler_manager;
-        $this->command_bus_middleware = is_array($command_bus_middleware)
-            ? $command_bus_middleware
-            : array($command_bus_middleware);
-    }
+	/**
+	 * CommandBus constructor
+	 *
+	 * @param CommandHandlerManagerInterface  $command_handler_manager
+	 * @param CommandBusMiddlewareInterface[] $command_bus_middleware
+	 */
+	public function __construct(
+		CommandHandlerManagerInterface $command_handler_manager,
+		array $command_bus_middleware = array()
+	) {
+		$this->command_handler_manager = $command_handler_manager;
+		$this->command_bus_middleware = is_array($command_bus_middleware)
+			? $command_bus_middleware
+			: array($command_bus_middleware);
+	}
 
 
-    /**
-     * @return CommandHandlerManagerInterface
-     */
-    public function getCommandHandlerManager()
-    {
-        return $this->command_handler_manager;
-    }
+	/**
+	 * @return CommandHandlerManagerInterface
+	 */
+	public function getCommandHandlerManager()
+	{
+		return $this->command_handler_manager;
+	}
 
 
-    /**
-     * @param CommandInterface $command
-     * @return mixed
-     * @throws InvalidDataTypeException
-     * @throws InvalidCommandBusMiddlewareException
-     */
-    public function execute($command)
-    {
-        if (! $command instanceof CommandInterface) {
-            throw new InvalidDataTypeException(__METHOD__ . '( $command )', $command, 'CommandInterface');
-        }
-        // we're going to add the Command Handler as a callable
-        // that will get run at the end of our middleware stack
-        // can't pass $this to a Closure, so use a named variable
-        $command_bus = $this;
-        $middleware = static function ($command) use ($command_bus) {
-            return $command_bus->getCommandHandlerManager()
-                               ->getCommandHandler($command, $command_bus)
-                               ->verify($command)
-                               ->handle($command);
-        };
-        // now build the rest of the middleware stack
-        while ($command_bus_middleware = array_pop($this->command_bus_middleware)) {
-            if (! $command_bus_middleware instanceof CommandBusMiddlewareInterface) {
-                throw new InvalidCommandBusMiddlewareException($command_bus_middleware);
-            }
-            $middleware = static function ($command) use ($command_bus_middleware, $middleware) {
-                return $command_bus_middleware->handle($command, $middleware);
-            };
-        }
-        // and finally, pass the command into the stack and return the results
-        return $middleware($command);
-    }
+	/**
+	 * @param CommandInterface $command
+	 * @return mixed
+	 * @throws InvalidDataTypeException
+	 * @throws InvalidCommandBusMiddlewareException
+	 */
+	public function execute($command)
+	{
+		if (! $command instanceof CommandInterface) {
+			throw new InvalidDataTypeException(__METHOD__ . '( $command )', $command, 'CommandInterface');
+		}
+		// we're going to add the Command Handler as a callable
+		// that will get run at the end of our middleware stack
+		// can't pass $this to a Closure, so use a named variable
+		$command_bus = $this;
+		$middleware = static function ($command) use ($command_bus) {
+			return $command_bus->getCommandHandlerManager()
+							   ->getCommandHandler($command, $command_bus)
+							   ->verify($command)
+							   ->handle($command);
+		};
+		// now build the rest of the middleware stack
+		while ($command_bus_middleware = array_pop($this->command_bus_middleware)) {
+			if (! $command_bus_middleware instanceof CommandBusMiddlewareInterface) {
+				throw new InvalidCommandBusMiddlewareException($command_bus_middleware);
+			}
+			$middleware = static function ($command) use ($command_bus_middleware, $middleware) {
+				return $command_bus_middleware->handle($command, $middleware);
+			};
+		}
+		// and finally, pass the command into the stack and return the results
+		return $middleware($command);
+	}
 }

Spacing +5 added lines, -5 removed lines

@@ -79,14 +79,14 @@ 
      */
     public function execute($command)
     {
-        if (! $command instanceof CommandInterface) {
-            throw new InvalidDataTypeException(__METHOD__ . '( $command )', $command, 'CommandInterface');
+        if ( ! $command instanceof CommandInterface) {
+            throw new InvalidDataTypeException(__METHOD__.'( $command )', $command, 'CommandInterface');
         }
         // we're going to add the Command Handler as a callable
         // that will get run at the end of our middleware stack
         // can't pass $this to a Closure, so use a named variable
         $command_bus = $this;
-        $middleware = static function ($command) use ($command_bus) {
+        $middleware = static function($command) use ($command_bus) {
             return $command_bus->getCommandHandlerManager()
                                ->getCommandHandler($command, $command_bus)
                                ->verify($command)
@@ -94,10 +94,10 @@ 
         };
         // now build the rest of the middleware stack
         while ($command_bus_middleware = array_pop($this->command_bus_middleware)) {
-            if (! $command_bus_middleware instanceof CommandBusMiddlewareInterface) {
+            if ( ! $command_bus_middleware instanceof CommandBusMiddlewareInterface) {
                 throw new InvalidCommandBusMiddlewareException($command_bus_middleware);
             }
-            $middleware = static function ($command) use ($command_bus_middleware, $middleware) {
+            $middleware = static function($command) use ($command_bus_middleware, $middleware) {
                 return $command_bus_middleware->handle($command, $middleware);
             };
         }