eventespresso / event-espresso-core

core/services/container/OpenCoffeeShop.php

Indentation +32 added lines, -32 removed lines

@@ -33,7 +33,7 @@ 
 	 * OpenCoffeeShop constructor.
 	 */
 	public function __construct()
-    {
+	{
 		// instantiate the container
 		$this->CoffeeShop = new CoffeeShop();
 		// create a dependency injector class for resolving class constructor arguments
@@ -83,11 +83,11 @@ 
 			new Recipe(
 				'CommandHandlerManager',
 				'EventEspresso\core\services\commands\CommandHandlerManager',
-                array(
-                    'CommandHandlerManagerInterface',
-                    'EventEspresso\core\services\commands\CommandHandlerManagerInterface',
-                ),
-                array(),
+				array(
+					'CommandHandlerManagerInterface',
+					'EventEspresso\core\services\commands\CommandHandlerManagerInterface',
+				),
+				array(),
 				CoffeeMaker::BREW_SHARED
 			)
 		);
@@ -96,11 +96,11 @@ 
 			new Recipe(
 				'CommandBus',
 				'EventEspresso\core\services\commands\CommandBus',
-                array(
-                    'CommandBusInterface',
-                    'EventEspresso\core\services\commands\CommandBusInterface',
-                ),
-                array(),
+				array(
+					'CommandBusInterface',
+					'EventEspresso\core\services\commands\CommandBusInterface',
+				),
+				array(),
 				CoffeeMaker::BREW_SHARED
 			)
 		);
@@ -110,22 +110,22 @@ 
 			new Recipe(
 				'EEI_*',
 				'',
-                array(),
-                array(),
+				array(),
+				array(),
 				CoffeeMaker::BREW_LOAD_ONLY,
-                array(
-                    EE_INTERFACES . '*.php',
-                    EE_INTERFACES . '*.interfaces.php',
-                )
+				array(
+					EE_INTERFACES . '*.php',
+					EE_INTERFACES . '*.interfaces.php',
+				)
 			)
 		);
 		// add a wildcard recipe for loading models
 		$this->CoffeeShop->addRecipe(
 			new Recipe(
 				'EEM_*',
-                '',
-                array(),
-                array(),
+				'',
+				array(),
+				array(),
 				CoffeeMaker::BREW_SHARED,
 				EE_MODELS . '*.model.php'
 			)
@@ -134,10 +134,10 @@ 
 		$this->CoffeeShop->addRecipe(
 			new Recipe(
 				'EE_*',
-                '',
-                array(),
-                array(),
-                CoffeeMaker::BREW_SHARED,
+				'',
+				array(),
+				array(),
+				CoffeeMaker::BREW_SHARED,
 				array(
 					EE_CORE . '*.core.php',
 					EE_ADMIN . '*.core.php',
@@ -152,10 +152,10 @@ 
 		$this->CoffeeShop->addRecipe(
 			new Recipe(
 				'EE_Admin_Page*',
-                '',
-                array(),
-                array(),
-                CoffeeMaker::BREW_LOAD_ONLY,
+				'',
+				array(),
+				array(),
+				CoffeeMaker::BREW_LOAD_ONLY,
 				array( EE_ADMIN . '*.core.php' )
 			)
 		);
@@ -163,10 +163,10 @@ 
 		// $this->CoffeeShop->addRecipe(
 		// 	new Recipe(
 		// 		'*_Admin_Page',
-        //      '',
-        //      array(),
-        // 		array(),
-        // 		CoffeeMaker::BREW_SHARED,
+		//      '',
+		//      array(),
+		// 		array(),
+		// 		CoffeeMaker::BREW_SHARED,
 		// 		array(
 		// 			EE_ADMIN_PAGES . 'transactions' . DS . '*.core.php',
 		// 		)

Spacing +15 added lines, -15 removed lines

@@ -1,8 +1,8 @@ 
 <?php
 namespace EventEspresso\core\services\container;
 
-if ( ! defined( 'EVENT_ESPRESSO_VERSION' ) ) {
-	exit( 'No direct script access allowed' );
+if ( ! defined('EVENT_ESPRESSO_VERSION')) {
+	exit('No direct script access allowed');
 }
 
 
@@ -43,17 +43,17 @@ 
 		);
 		// and some coffeemakers, one for creating new instances
 		$this->CoffeeShop->addCoffeeMaker(
-			new NewCoffeeMaker( $this->CoffeeShop, $this->DependencyInjector ),
+			new NewCoffeeMaker($this->CoffeeShop, $this->DependencyInjector),
 			CoffeeMaker::BREW_NEW
 		);
 		// one for shared services
 		$this->CoffeeShop->addCoffeeMaker(
-			new SharedCoffeeMaker( $this->CoffeeShop, $this->DependencyInjector ),
+			new SharedCoffeeMaker($this->CoffeeShop, $this->DependencyInjector),
 			CoffeeMaker::BREW_SHARED
 		);
 		// and one for classes that only get loaded
 		$this->CoffeeShop->addCoffeeMaker(
-			new LoadOnlyCoffeeMaker( $this->CoffeeShop, $this->DependencyInjector ),
+			new LoadOnlyCoffeeMaker($this->CoffeeShop, $this->DependencyInjector),
 			CoffeeMaker::BREW_LOAD_ONLY
 		);
 		// add default recipe, which should handle loading for most PSR-4 compatible classes
@@ -114,8 +114,8 @@ 
                 array(),
 				CoffeeMaker::BREW_LOAD_ONLY,
                 array(
-                    EE_INTERFACES . '*.php',
-                    EE_INTERFACES . '*.interfaces.php',
+                    EE_INTERFACES.'*.php',
+                    EE_INTERFACES.'*.interfaces.php',
                 )
 			)
 		);
@@ -127,7 +127,7 @@ 
                 array(),
                 array(),
 				CoffeeMaker::BREW_SHARED,
-				EE_MODELS . '*.model.php'
+				EE_MODELS.'*.model.php'
 			)
 		);
 		// add a wildcard recipe for loading core classes
@@ -139,12 +139,12 @@ 
                 array(),
                 CoffeeMaker::BREW_SHARED,
 				array(
-					EE_CORE . '*.core.php',
-					EE_ADMIN . '*.core.php',
-					EE_CPTS . '*.core.php',
-					EE_CORE . 'data_migration_scripts' . DS . '*.core.php',
-					EE_CORE . 'request_stack' . DS . '*.core.php',
-					EE_CORE . 'middleware' . DS . '*.core.php',
+					EE_CORE.'*.core.php',
+					EE_ADMIN.'*.core.php',
+					EE_CPTS.'*.core.php',
+					EE_CORE.'data_migration_scripts'.DS.'*.core.php',
+					EE_CORE.'request_stack'.DS.'*.core.php',
+					EE_CORE.'middleware'.DS.'*.core.php',
 				)
 			)
 		);
@@ -156,7 +156,7 @@ 
                 array(),
                 array(),
                 CoffeeMaker::BREW_LOAD_ONLY,
-				array( EE_ADMIN . '*.core.php' )
+				array(EE_ADMIN.'*.core.php')
 			)
 		);
 		// add a wildcard recipe for loading core classes

core/services/container/Recipe.php

Indentation +308 added lines, -308 removed lines

@@ -7,7 +7,7 @@ 
 use RuntimeException;
 
 if ( ! defined('EVENT_ESPRESSO_VERSION')) {
-    exit('No direct script access allowed');
+	exit('No direct script access allowed');
 }
 
 
@@ -23,313 +23,313 @@ 
 class Recipe implements RecipeInterface
 {
 
-    /**
-     * A default Recipe to use if none is specified for a class
-     */
-    const DEFAULT_ID = '*';
-
-    /**
-     * Identifier for the entity class to be constructed.
-     * Typically a Fully Qualified Class Name
-     *
-     * @var string $identifier
-     */
-    private $identifier;
-
-    /**
-     * Fully Qualified Class Name
-     *
-     * @var string $fqcn
-     */
-    private $fqcn;
-
-    /**
-     * a dependency class map array
-     * If a Recipe is for a single class (or group of classes that shares the EXACT SAME constructor arguments),
-     * and that class type hints for an interface, then this property allows you to configure what dependencies
-     * get used when instantiating the class.
-     * For example:
-     *  There's a class called Coffee, and one of its constructor arguments is BeanInterface
-     *  There are two implementations of BeanInterface: HonduranBean, and KenyanBean
-     *  We want one Coffee object to use HonduranBean for its BeanInterface,
-     *  and the 2nd Coffee object to use KenyanBean for its BeanInterface.
-     *  To do this, we need to create two Recipes:
-     *      one with an identifier of 'HonduranCoffee' using the following ingredients :
-     *          array('BeanInterface' => 'HonduranBean')
-     *      and the other with an identifier of 'KenyanCoffee' using the following ingredients :
-     *          array('BeanInterface' => 'KenyanBean')
-     *  Then, whenever the CoffeeShop brews an instance of HonduranCoffee,
-     *  an instance of HonduranBean will get injected for the BeanInterface dependency,
-     *  and whenever the CoffeeShop brews an instance of KenyanCoffee,
-     *  an instance of KenyanBean will get injected for the BeanInterface dependency
-     *
-     * @var array $ingredients
-     */
-    private $ingredients = array();
-
-    /**
-     * one of the class constants from CoffeeShop:
-     *  CoffeeMaker::BREW_NEW - creates a new instance
-     *  CoffeeMaker::BREW_SHARED - creates a shared instance
-     *  CoffeeMaker::BREW_LOAD_ONLY - loads but does not instantiate
-     *
-     * @var string $type
-     */
-    private $type;
-
-    /**
-     * class name aliases - typically a Fully Qualified Interface that the class implements
-     * identifiers passed to the CoffeeShop will be run through the filters to find the correct class name
-     *
-     * @var array $filters
-     */
-    private $filters = array();
-
-    /**
-     * array of full server filepaths to files that may contain the class
-     *
-     * @var array $paths
-     */
-    private $paths = array();
-
-
-
-    /**
-     * Recipe constructor.
-     *
-     * @param string $identifier    class identifier, can be an alias, or FQCN, or whatever
-     * @param string $fqcn          \Fully\Qualified\ClassName, optional if $identifier is FQCN
-     * @param array  $ingredients   array of dependencies that can not be resolved automatically,
-     *                              used for resolving concrete classes for type hinted interfaces
-     *                              for the dependencies of THIS class
-     * @param string $type          recipe type: one of the class constants on
-     *                              \EventEspresso\core\services\container\CoffeeMaker
-     * @param array  $filters       array of class aliases, or class interfaces
-     *                              this works somewhat opposite to the $ingredients array above,
-     *                              in that this array specifies interfaces or aliases
-     *                              that this Recipe can be used for when resolving OTHER class's dependencies
-     * @param array  $paths         if class can not be loaded via PSR-4 autoloading,
-     *                              then supply a filepath, or array of filepaths, so that it can be included
-     */
-    public function __construct(
-	    $identifier,
-        $fqcn = '',
-        $filters = array(),
-        $ingredients = array(),
-	    $type = CoffeeMaker::BREW_NEW,
-	    $paths = array()
-    )
-    {
-        $this->setIdentifier($identifier);
-        $this->setFilters((array)$filters);
-        $this->setIngredients((array)$ingredients);
-        $this->setType($type);
-        $this->setPaths($paths);
-        $this->setFqcn($fqcn);
-    }
-
-
-
-    /**
-     * @return string
-     */
-    public function identifier()
-    {
-        return $this->identifier;
-    }
-
-
-
-    /**
-     * @return string
-     */
-    public function fqcn()
-    {
-        return $this->fqcn;
-    }
-
-
-
-    /**
-     * @return array
-     */
-    public function filters()
-    {
-        return (array)$this->filters;
-    }
-
-
-
-    /**
-     * @return array
-     */
-    public function ingredients()
-    {
-        return $this->ingredients;
-    }
-
-
-
-    /**
-     * @return string
-     */
-    public function type()
-    {
-        return $this->type;
-    }
-
-
-
-    /**
-     * @return array
-     */
-    public function paths()
-    {
-        return (array)$this->paths;
-    }
-
-
-
-    /**
-     * @param  string $identifier Identifier for the entity class that the Recipe applies to
-     *                            Typically a Fully Qualified Class Name
-     */
-    public function setIdentifier($identifier)
-    {
-        if ( ! is_string($identifier) || empty($identifier)) {
-            throw new InvalidIdentifierException(
-                is_object($identifier) ? get_class($identifier) : gettype($identifier),
-                __('class identifier (typically a \Fully\Qualified\ClassName)', 'event_espresso')
-            );
-        }
-        $this->identifier = $identifier;
-    }
-
-
-
-    /**
-     * Ensures incoming string is a valid Fully Qualified Class Name,
-     * except if this is the default wildcard Recipe ( * ),
-     * or it's NOT an actual FQCN because the Recipe is using filepaths
-     * for classes that are not PSR-4 compatible
-     * PLZ NOTE:
-     *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
-     *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
-     *
-     * @param string $fqcn
-     */
-    public function setFqcn($fqcn)
-    {
-	    $fqcn = ! empty($fqcn) ? $fqcn : $this->identifier;
-        if ( ! is_string($fqcn)) {
-            throw new InvalidDataTypeException(
-                '$fqcn',
-                is_object($fqcn) ? get_class($fqcn) : gettype($fqcn),
-                __('string (Fully\Qualified\ClassName)', 'event_espresso')
-            );
-        }
-        $fqcn = ltrim($fqcn, '\\');
-        if (
-            $fqcn !== Recipe::DEFAULT_ID
-            && ! empty($fqcn)
-            && empty($this->paths)
-            && ! class_exists($fqcn)
-        ) {
-            throw new InvalidClassException($fqcn);
-        }
-        $this->fqcn = $fqcn;
-    }
-
-
-
-    /**
-     * @param array $ingredients    an array of dependencies where keys are the aliases and values are the FQCNs
-     *                              example:
-     *                              array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
-     */
-    public function setIngredients(array $ingredients)
-    {
-        if (empty($ingredients)) {
-            return;
-        }
-        if ( ! is_array($ingredients)) {
-            throw new InvalidDataTypeException(
-                '$ingredients',
-                is_object($ingredients) ? get_class($ingredients) : gettype($ingredients),
-                __('array of class dependencies', 'event_espresso')
-            );
-        }
-        $this->ingredients = array_merge($this->ingredients, $ingredients);
-    }
-
-
-    /**
-     * @param string $type one of the class constants returned from CoffeeMaker::getTypes()
-     */
-    public function setType($type = CoffeeMaker::BREW_NEW)
-    {
-        $this->type = CoffeeMaker::validateType($type);
-    }
-
-
-
-    /**
-     * @param array $filters an array of filters where keys are the aliases and values are the FQCNs
-     *                          example:
-     *                          array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
-     */
-    public function setFilters(array $filters)
-    {
-        if (empty($filters)) {
-            return;
-        }
-        if ( ! is_array($filters)) {
-            throw new InvalidDataTypeException(
-                '$filters',
-                is_object($filters) ? get_class($filters) : gettype($filters),
-                __('array of class aliases', 'event_espresso')
-            );
-        }
-        $this->filters = array_merge($this->filters, $filters);
-    }
-
-
-
-    /**
-     * Ensures incoming paths is a valid filepath, or array of valid filepaths,
-     * and merges them in with any existing filepaths
-     *
-     * PLZ NOTE:
-     *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
-     *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
-     *
-     * @param string|array $paths
-     */
-    public function setPaths($paths = array())
-    {
-        if (empty($paths)) {
-            return;
-        }
-        if ( ! (is_string($paths) || is_array($paths))) {
-            throw new InvalidDataTypeException(
-                '$path',
-                is_object($paths) ? get_class($paths) : gettype($paths),
-                __('string or array of strings (full server filepath(s))', 'event_espresso')
-            );
-        }
-        $paths = (array)$paths;
-        foreach ($paths as $path) {
-            if (strpos($path, '*') === false && ! is_readable($path)) {
-                throw new RuntimeException(
-                    sprintf(
-                        __('The following filepath is not readable: "%1$s"', 'event_espresso'),
-                        $path
-                    )
-                );
-            }
-        }
-        $this->paths = array_merge($this->paths, $paths);
-    }
+	/**
+	 * A default Recipe to use if none is specified for a class
+	 */
+	const DEFAULT_ID = '*';
+
+	/**
+	 * Identifier for the entity class to be constructed.
+	 * Typically a Fully Qualified Class Name
+	 *
+	 * @var string $identifier
+	 */
+	private $identifier;
+
+	/**
+	 * Fully Qualified Class Name
+	 *
+	 * @var string $fqcn
+	 */
+	private $fqcn;
+
+	/**
+	 * a dependency class map array
+	 * If a Recipe is for a single class (or group of classes that shares the EXACT SAME constructor arguments),
+	 * and that class type hints for an interface, then this property allows you to configure what dependencies
+	 * get used when instantiating the class.
+	 * For example:
+	 *  There's a class called Coffee, and one of its constructor arguments is BeanInterface
+	 *  There are two implementations of BeanInterface: HonduranBean, and KenyanBean
+	 *  We want one Coffee object to use HonduranBean for its BeanInterface,
+	 *  and the 2nd Coffee object to use KenyanBean for its BeanInterface.
+	 *  To do this, we need to create two Recipes:
+	 *      one with an identifier of 'HonduranCoffee' using the following ingredients :
+	 *          array('BeanInterface' => 'HonduranBean')
+	 *      and the other with an identifier of 'KenyanCoffee' using the following ingredients :
+	 *          array('BeanInterface' => 'KenyanBean')
+	 *  Then, whenever the CoffeeShop brews an instance of HonduranCoffee,
+	 *  an instance of HonduranBean will get injected for the BeanInterface dependency,
+	 *  and whenever the CoffeeShop brews an instance of KenyanCoffee,
+	 *  an instance of KenyanBean will get injected for the BeanInterface dependency
+	 *
+	 * @var array $ingredients
+	 */
+	private $ingredients = array();
+
+	/**
+	 * one of the class constants from CoffeeShop:
+	 *  CoffeeMaker::BREW_NEW - creates a new instance
+	 *  CoffeeMaker::BREW_SHARED - creates a shared instance
+	 *  CoffeeMaker::BREW_LOAD_ONLY - loads but does not instantiate
+	 *
+	 * @var string $type
+	 */
+	private $type;
+
+	/**
+	 * class name aliases - typically a Fully Qualified Interface that the class implements
+	 * identifiers passed to the CoffeeShop will be run through the filters to find the correct class name
+	 *
+	 * @var array $filters
+	 */
+	private $filters = array();
+
+	/**
+	 * array of full server filepaths to files that may contain the class
+	 *
+	 * @var array $paths
+	 */
+	private $paths = array();
+
+
+
+	/**
+	 * Recipe constructor.
+	 *
+	 * @param string $identifier    class identifier, can be an alias, or FQCN, or whatever
+	 * @param string $fqcn          \Fully\Qualified\ClassName, optional if $identifier is FQCN
+	 * @param array  $ingredients   array of dependencies that can not be resolved automatically,
+	 *                              used for resolving concrete classes for type hinted interfaces
+	 *                              for the dependencies of THIS class
+	 * @param string $type          recipe type: one of the class constants on
+	 *                              \EventEspresso\core\services\container\CoffeeMaker
+	 * @param array  $filters       array of class aliases, or class interfaces
+	 *                              this works somewhat opposite to the $ingredients array above,
+	 *                              in that this array specifies interfaces or aliases
+	 *                              that this Recipe can be used for when resolving OTHER class's dependencies
+	 * @param array  $paths         if class can not be loaded via PSR-4 autoloading,
+	 *                              then supply a filepath, or array of filepaths, so that it can be included
+	 */
+	public function __construct(
+		$identifier,
+		$fqcn = '',
+		$filters = array(),
+		$ingredients = array(),
+		$type = CoffeeMaker::BREW_NEW,
+		$paths = array()
+	)
+	{
+		$this->setIdentifier($identifier);
+		$this->setFilters((array)$filters);
+		$this->setIngredients((array)$ingredients);
+		$this->setType($type);
+		$this->setPaths($paths);
+		$this->setFqcn($fqcn);
+	}
+
+
+
+	/**
+	 * @return string
+	 */
+	public function identifier()
+	{
+		return $this->identifier;
+	}
+
+
+
+	/**
+	 * @return string
+	 */
+	public function fqcn()
+	{
+		return $this->fqcn;
+	}
+
+
+
+	/**
+	 * @return array
+	 */
+	public function filters()
+	{
+		return (array)$this->filters;
+	}
+
+
+
+	/**
+	 * @return array
+	 */
+	public function ingredients()
+	{
+		return $this->ingredients;
+	}
+
+
+
+	/**
+	 * @return string
+	 */
+	public function type()
+	{
+		return $this->type;
+	}
+
+
+
+	/**
+	 * @return array
+	 */
+	public function paths()
+	{
+		return (array)$this->paths;
+	}
+
+
+
+	/**
+	 * @param  string $identifier Identifier for the entity class that the Recipe applies to
+	 *                            Typically a Fully Qualified Class Name
+	 */
+	public function setIdentifier($identifier)
+	{
+		if ( ! is_string($identifier) || empty($identifier)) {
+			throw new InvalidIdentifierException(
+				is_object($identifier) ? get_class($identifier) : gettype($identifier),
+				__('class identifier (typically a \Fully\Qualified\ClassName)', 'event_espresso')
+			);
+		}
+		$this->identifier = $identifier;
+	}
+
+
+
+	/**
+	 * Ensures incoming string is a valid Fully Qualified Class Name,
+	 * except if this is the default wildcard Recipe ( * ),
+	 * or it's NOT an actual FQCN because the Recipe is using filepaths
+	 * for classes that are not PSR-4 compatible
+	 * PLZ NOTE:
+	 *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
+	 *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
+	 *
+	 * @param string $fqcn
+	 */
+	public function setFqcn($fqcn)
+	{
+		$fqcn = ! empty($fqcn) ? $fqcn : $this->identifier;
+		if ( ! is_string($fqcn)) {
+			throw new InvalidDataTypeException(
+				'$fqcn',
+				is_object($fqcn) ? get_class($fqcn) : gettype($fqcn),
+				__('string (Fully\Qualified\ClassName)', 'event_espresso')
+			);
+		}
+		$fqcn = ltrim($fqcn, '\\');
+		if (
+			$fqcn !== Recipe::DEFAULT_ID
+			&& ! empty($fqcn)
+			&& empty($this->paths)
+			&& ! class_exists($fqcn)
+		) {
+			throw new InvalidClassException($fqcn);
+		}
+		$this->fqcn = $fqcn;
+	}
+
+
+
+	/**
+	 * @param array $ingredients    an array of dependencies where keys are the aliases and values are the FQCNs
+	 *                              example:
+	 *                              array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
+	 */
+	public function setIngredients(array $ingredients)
+	{
+		if (empty($ingredients)) {
+			return;
+		}
+		if ( ! is_array($ingredients)) {
+			throw new InvalidDataTypeException(
+				'$ingredients',
+				is_object($ingredients) ? get_class($ingredients) : gettype($ingredients),
+				__('array of class dependencies', 'event_espresso')
+			);
+		}
+		$this->ingredients = array_merge($this->ingredients, $ingredients);
+	}
+
+
+	/**
+	 * @param string $type one of the class constants returned from CoffeeMaker::getTypes()
+	 */
+	public function setType($type = CoffeeMaker::BREW_NEW)
+	{
+		$this->type = CoffeeMaker::validateType($type);
+	}
+
+
+
+	/**
+	 * @param array $filters an array of filters where keys are the aliases and values are the FQCNs
+	 *                          example:
+	 *                          array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
+	 */
+	public function setFilters(array $filters)
+	{
+		if (empty($filters)) {
+			return;
+		}
+		if ( ! is_array($filters)) {
+			throw new InvalidDataTypeException(
+				'$filters',
+				is_object($filters) ? get_class($filters) : gettype($filters),
+				__('array of class aliases', 'event_espresso')
+			);
+		}
+		$this->filters = array_merge($this->filters, $filters);
+	}
+
+
+
+	/**
+	 * Ensures incoming paths is a valid filepath, or array of valid filepaths,
+	 * and merges them in with any existing filepaths
+	 *
+	 * PLZ NOTE:
+	 *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
+	 *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
+	 *
+	 * @param string|array $paths
+	 */
+	public function setPaths($paths = array())
+	{
+		if (empty($paths)) {
+			return;
+		}
+		if ( ! (is_string($paths) || is_array($paths))) {
+			throw new InvalidDataTypeException(
+				'$path',
+				is_object($paths) ? get_class($paths) : gettype($paths),
+				__('string or array of strings (full server filepath(s))', 'event_espresso')
+			);
+		}
+		$paths = (array)$paths;
+		foreach ($paths as $path) {
+			if (strpos($path, '*') === false && ! is_readable($path)) {
+				throw new RuntimeException(
+					sprintf(
+						__('The following filepath is not readable: "%1$s"', 'event_espresso'),
+						$path
+					)
+				);
+			}
+		}
+		$this->paths = array_merge($this->paths, $paths);
+	}
 
 
 

Spacing +5 added lines, -5 removed lines

@@ -121,8 +121,8 @@ 
     )
     {
         $this->setIdentifier($identifier);
-        $this->setFilters((array)$filters);
-        $this->setIngredients((array)$ingredients);
+        $this->setFilters((array) $filters);
+        $this->setIngredients((array) $ingredients);
         $this->setType($type);
         $this->setPaths($paths);
         $this->setFqcn($fqcn);
@@ -155,7 +155,7 @@ 
      */
     public function filters()
     {
-        return (array)$this->filters;
+        return (array) $this->filters;
     }
 
 
@@ -185,7 +185,7 @@ 
      */
     public function paths()
     {
-        return (array)$this->paths;
+        return (array) $this->paths;
     }
 
 
@@ -317,7 +317,7 @@ 
                 __('string or array of strings (full server filepath(s))', 'event_espresso')
             );
         }
-        $paths = (array)$paths;
+        $paths = (array) $paths;
         foreach ($paths as $path) {
             if (strpos($path, '*') === false && ! is_readable($path)) {
                 throw new RuntimeException(

core/services/container/DependencyInjector.php

Indentation +209 added lines, -209 removed lines

@@ -4,7 +4,7 @@ 
 use UnexpectedValueException;
 
 if ( ! defined('EVENT_ESPRESSO_VERSION')) {
-    exit('No direct script access allowed');
+	exit('No direct script access allowed');
 }
 
 
@@ -22,214 +22,214 @@ 
 class DependencyInjector implements InjectorInterface
 {
 
-    /**
-     * @var CoffeePotInterface $coffee_pot
-     */
-    private $coffee_pot;
-
-    /**
-     * @var \EEH_Array $array_helper
-     */
-    private $array_helper;
-
-    /**
-     * @var \ReflectionClass[] $reflectors
-     */
-    private $reflectors;
-
-    /**
-     * @var \ReflectionMethod[] $constructors
-     */
-    private $constructors;
-
-    /**
-     * @var \ReflectionParameter[] $parameters
-     */
-    private $parameters;
-
-
-
-    /**
-     * DependencyInjector constructor
-     *
-     * @param CoffeePotInterface $coffee_pot
-     * @param \EEH_Array         $array_helper
-     */
-    public function __construct(CoffeePotInterface $coffee_pot, \EEH_Array $array_helper)
-    {
-        $this->coffee_pot = $coffee_pot;
-        $this->array_helper = $array_helper;
-    }
-
-
-
-    /**
-     * getReflectionClass
-     * checks if a ReflectionClass object has already been generated for a class
-     * and returns that instead of creating a new one
-     *
-     * @param string $class_name
-     * @return \ReflectionClass
-     */
-    public function getReflectionClass($class_name)
-    {
-        if (
-            ! isset($this->reflectors[$class_name])
-            || ! $this->reflectors[$class_name] instanceof \ReflectionClass
-        ) {
-            $this->reflectors[$class_name] = new \ReflectionClass($class_name);
-        }
-        return $this->reflectors[$class_name];
-    }
-
-
-
-    /**
-     * getConstructor
-     * checks if a ReflectionMethod object has already been generated for the class constructor
-     * and returns that instead of creating a new one
-     *
-     * @param \ReflectionClass $reflector
-     * @return \ReflectionMethod
-     */
-    protected function getConstructor(\ReflectionClass $reflector)
-    {
-        if (
-            ! isset($this->constructors[$reflector->getName()])
-            || ! $this->constructors[$reflector->getName()] instanceof \ReflectionMethod
-        ) {
-            $this->constructors[$reflector->getName()] = $reflector->getConstructor();
-        }
-        return $this->constructors[$reflector->getName()];
-    }
-
-
-
-    /**
-     * getParameters
-     * checks if an array of ReflectionParameter objects has already been generated for the class constructor
-     * and returns that instead of creating a new one
-     *
-     * @param \ReflectionMethod $constructor
-     * @return \ReflectionParameter[]
-     */
-    protected function getParameters(\ReflectionMethod $constructor)
-    {
-        if ( ! isset($this->parameters[$constructor->class])) {
-            $this->parameters[$constructor->class] = $constructor->getParameters();
-        }
-        return $this->parameters[$constructor->class];
-    }
-
-
-
-    /**
-     * resolveDependencies
-     * examines the constructor for the requested class to determine
-     * if any dependencies exist, and if they can be injected.
-     * If so, then those classes will be added to the array of arguments passed to the constructor
-     * PLZ NOTE: this is achieved by type hinting the constructor params
-     * For example:
-     *        if attempting to load a class "Foo" with the following constructor:
-     *        __construct( Bar $bar_class, Fighter $grohl_class )
-     *        then $bar_class and $grohl_class will be added to the $arguments array,
-     *        but only IF they are NOT already present in the incoming arguments array,
-     *        and the correct classes can be loaded
-     *
-     * @param RecipeInterface   $recipe
-     * @param \ReflectionClass  $reflector
-     * @param array             $arguments
-     * @return array
-     */
-    public function resolveDependencies(RecipeInterface $recipe, \ReflectionClass $reflector, $arguments = array())
-    {
-        // if arguments array is numerically and sequentially indexed, then we want it to remain as is,
-        // else wrap it in an additional array so that it doesn't get split into multiple parameters
-        $arguments = $this->array_helper->is_array_numerically_and_sequentially_indexed($arguments)
-            ? $arguments
-            : array($arguments);
-        $resolved_parameters = array();
-        // let's examine the constructor
-        // let's examine the constructor
-        $constructor = $this->getConstructor($reflector);
-        // whu? huh? nothing?
-        if ( ! $constructor) {
-            return $arguments;
-        }
-        // get constructor parameters
-        $params = $this->getParameters($constructor);
-        if (empty($params)) {
-            return $resolved_parameters;
-        }
-        $ingredients = $recipe->ingredients();
-        // and the keys for the incoming arguments array so that we can compare existing arguments with what is expected
-        $argument_keys = array_keys($arguments);
-        // now loop thru all of the constructors expected parameters
-        foreach ($params as $index => $param) {
-            if ( ! $param instanceof \ReflectionParameter) {
-                continue;
-            }
-            // is this a dependency for a specific class ?
-            $param_class = $param->getClass() ? $param->getClass()->name : null;
-            if (
-                // param is specified in the list of ingredients for this Recipe
-                isset($ingredients[$param_class])
-            ) {
-                // attempt to inject the dependency
-                $resolved_parameters[$index] = $this->injectDependency($ingredients[$param_class]);
-            } else if (
-                // param is not even a class
-                empty($param_class)
-                // and something already exists in the incoming arguments for this param
-                && isset($argument_keys[$index], $arguments[$argument_keys[$index]])
-            ) {
-                // add parameter from incoming arguments
-                $resolved_parameters[$index] = $arguments[$argument_keys[$index]];
-            } else if (
-                // parameter is type hinted as a class, exists as an incoming argument, AND it's the correct class
-                ! empty($param_class)
-                && isset($argument_keys[$index], $arguments[$argument_keys[$index]])
-                && $arguments[$argument_keys[$index]] instanceof $param_class
-            ) {
-                // add parameter from incoming arguments
-                $resolved_parameters[$index] = $arguments[$argument_keys[$index]];
-            } else if (
-                // parameter is type hinted as a class, and should be injected
-            ! empty($param_class)
-            ) {
-                // attempt to inject the dependency
-                $resolved_parameters[$index] = $this->injectDependency($param_class);
-            } else if ($param->isOptional()) {
-                $resolved_parameters[$index] = $param->getDefaultValue();
-            } else {
-                $resolved_parameters[$index] = null;
-            }
-        }
-        return $resolved_parameters;
-    }
-
-
-
-    /**
-     * @param string $param_class
-     * @return mixed
-     */
-    private function injectDependency($param_class)
-    {
-        $dependency = $this->coffee_pot->brew($param_class);
-        if ( ! $dependency instanceof $param_class) {
-            throw new UnexpectedValueException(
-                sprintf(
-                    __(
-                        'Could not resolve dependency for "%1$s" for the "%2$s" class constructor.',
-                        'event_espresso'
-                    ),
-                    $param_class
-                )
-            );
-        }
-        return $dependency;
-    }
+	/**
+	 * @var CoffeePotInterface $coffee_pot
+	 */
+	private $coffee_pot;
+
+	/**
+	 * @var \EEH_Array $array_helper
+	 */
+	private $array_helper;
+
+	/**
+	 * @var \ReflectionClass[] $reflectors
+	 */
+	private $reflectors;
+
+	/**
+	 * @var \ReflectionMethod[] $constructors
+	 */
+	private $constructors;
+
+	/**
+	 * @var \ReflectionParameter[] $parameters
+	 */
+	private $parameters;
+
+
+
+	/**
+	 * DependencyInjector constructor
+	 *
+	 * @param CoffeePotInterface $coffee_pot
+	 * @param \EEH_Array         $array_helper
+	 */
+	public function __construct(CoffeePotInterface $coffee_pot, \EEH_Array $array_helper)
+	{
+		$this->coffee_pot = $coffee_pot;
+		$this->array_helper = $array_helper;
+	}
+
+
+
+	/**
+	 * getReflectionClass
+	 * checks if a ReflectionClass object has already been generated for a class
+	 * and returns that instead of creating a new one
+	 *
+	 * @param string $class_name
+	 * @return \ReflectionClass
+	 */
+	public function getReflectionClass($class_name)
+	{
+		if (
+			! isset($this->reflectors[$class_name])
+			|| ! $this->reflectors[$class_name] instanceof \ReflectionClass
+		) {
+			$this->reflectors[$class_name] = new \ReflectionClass($class_name);
+		}
+		return $this->reflectors[$class_name];
+	}
+
+
+
+	/**
+	 * getConstructor
+	 * checks if a ReflectionMethod object has already been generated for the class constructor
+	 * and returns that instead of creating a new one
+	 *
+	 * @param \ReflectionClass $reflector
+	 * @return \ReflectionMethod
+	 */
+	protected function getConstructor(\ReflectionClass $reflector)
+	{
+		if (
+			! isset($this->constructors[$reflector->getName()])
+			|| ! $this->constructors[$reflector->getName()] instanceof \ReflectionMethod
+		) {
+			$this->constructors[$reflector->getName()] = $reflector->getConstructor();
+		}
+		return $this->constructors[$reflector->getName()];
+	}
+
+
+
+	/**
+	 * getParameters
+	 * checks if an array of ReflectionParameter objects has already been generated for the class constructor
+	 * and returns that instead of creating a new one
+	 *
+	 * @param \ReflectionMethod $constructor
+	 * @return \ReflectionParameter[]
+	 */
+	protected function getParameters(\ReflectionMethod $constructor)
+	{
+		if ( ! isset($this->parameters[$constructor->class])) {
+			$this->parameters[$constructor->class] = $constructor->getParameters();
+		}
+		return $this->parameters[$constructor->class];
+	}
+
+
+
+	/**
+	 * resolveDependencies
+	 * examines the constructor for the requested class to determine
+	 * if any dependencies exist, and if they can be injected.
+	 * If so, then those classes will be added to the array of arguments passed to the constructor
+	 * PLZ NOTE: this is achieved by type hinting the constructor params
+	 * For example:
+	 *        if attempting to load a class "Foo" with the following constructor:
+	 *        __construct( Bar $bar_class, Fighter $grohl_class )
+	 *        then $bar_class and $grohl_class will be added to the $arguments array,
+	 *        but only IF they are NOT already present in the incoming arguments array,
+	 *        and the correct classes can be loaded
+	 *
+	 * @param RecipeInterface   $recipe
+	 * @param \ReflectionClass  $reflector
+	 * @param array             $arguments
+	 * @return array
+	 */
+	public function resolveDependencies(RecipeInterface $recipe, \ReflectionClass $reflector, $arguments = array())
+	{
+		// if arguments array is numerically and sequentially indexed, then we want it to remain as is,
+		// else wrap it in an additional array so that it doesn't get split into multiple parameters
+		$arguments = $this->array_helper->is_array_numerically_and_sequentially_indexed($arguments)
+			? $arguments
+			: array($arguments);
+		$resolved_parameters = array();
+		// let's examine the constructor
+		// let's examine the constructor
+		$constructor = $this->getConstructor($reflector);
+		// whu? huh? nothing?
+		if ( ! $constructor) {
+			return $arguments;
+		}
+		// get constructor parameters
+		$params = $this->getParameters($constructor);
+		if (empty($params)) {
+			return $resolved_parameters;
+		}
+		$ingredients = $recipe->ingredients();
+		// and the keys for the incoming arguments array so that we can compare existing arguments with what is expected
+		$argument_keys = array_keys($arguments);
+		// now loop thru all of the constructors expected parameters
+		foreach ($params as $index => $param) {
+			if ( ! $param instanceof \ReflectionParameter) {
+				continue;
+			}
+			// is this a dependency for a specific class ?
+			$param_class = $param->getClass() ? $param->getClass()->name : null;
+			if (
+				// param is specified in the list of ingredients for this Recipe
+				isset($ingredients[$param_class])
+			) {
+				// attempt to inject the dependency
+				$resolved_parameters[$index] = $this->injectDependency($ingredients[$param_class]);
+			} else if (
+				// param is not even a class
+				empty($param_class)
+				// and something already exists in the incoming arguments for this param
+				&& isset($argument_keys[$index], $arguments[$argument_keys[$index]])
+			) {
+				// add parameter from incoming arguments
+				$resolved_parameters[$index] = $arguments[$argument_keys[$index]];
+			} else if (
+				// parameter is type hinted as a class, exists as an incoming argument, AND it's the correct class
+				! empty($param_class)
+				&& isset($argument_keys[$index], $arguments[$argument_keys[$index]])
+				&& $arguments[$argument_keys[$index]] instanceof $param_class
+			) {
+				// add parameter from incoming arguments
+				$resolved_parameters[$index] = $arguments[$argument_keys[$index]];
+			} else if (
+				// parameter is type hinted as a class, and should be injected
+			! empty($param_class)
+			) {
+				// attempt to inject the dependency
+				$resolved_parameters[$index] = $this->injectDependency($param_class);
+			} else if ($param->isOptional()) {
+				$resolved_parameters[$index] = $param->getDefaultValue();
+			} else {
+				$resolved_parameters[$index] = null;
+			}
+		}
+		return $resolved_parameters;
+	}
+
+
+
+	/**
+	 * @param string $param_class
+	 * @return mixed
+	 */
+	private function injectDependency($param_class)
+	{
+		$dependency = $this->coffee_pot->brew($param_class);
+		if ( ! $dependency instanceof $param_class) {
+			throw new UnexpectedValueException(
+				sprintf(
+					__(
+						'Could not resolve dependency for "%1$s" for the "%2$s" class constructor.',
+						'event_espresso'
+					),
+					$param_class
+				)
+			);
+		}
+		return $dependency;
+	}
 
 }
 // End of file DependencyInjector.php

core/services/container/InjectorInterface.php

Indentation +34 added lines, -34 removed lines

@@ -2,7 +2,7 @@ 
 namespace EventEspresso\core\services\container;
 
 if ( ! defined('EVENT_ESPRESSO_VERSION')) {
-    exit('No direct script access allowed');
+	exit('No direct script access allowed');
 }
 
 
@@ -17,39 +17,39 @@ 
 interface InjectorInterface
 {
 
-    /**
-     * getReflectionClass
-     * checks if a ReflectionClass object has already been generated for a class
-     * and returns that instead of creating a new one
-     *
-     * @access public
-     * @param string $class_name
-     * @return \ReflectionClass
-     */
-    public function getReflectionClass($class_name);
-
-
-
-    /**
-     * resolveDependencies
-     * examines the constructor for the requested class to determine
-     * if any dependencies exist, and if they can be injected.
-     * If so, then those classes will be added to the array of arguments passed to the constructor
-     * PLZ NOTE: this is achieved by type hinting the constructor params
-     * For example:
-     *        if attempting to load a class "Foo" with the following constructor:
-     *        __construct( Bar $bar_class, Fighter $grohl_class )
-     *        then $bar_class and $grohl_class will be added to the $arguments array,
-     *        but only IF they are NOT already present in the incoming arguments array,
-     *        and the correct classes can be loaded
-     *
-     * @access public
-     * @param \EventEspresso\core\services\container\RecipeInterface $recipe
-     * @param \ReflectionClass                                       $reflector
-     * @param array                                                  $arguments
-     * @return array
-     */
-    public function resolveDependencies(RecipeInterface $recipe, \ReflectionClass $reflector, $arguments = array());
+	/**
+	 * getReflectionClass
+	 * checks if a ReflectionClass object has already been generated for a class
+	 * and returns that instead of creating a new one
+	 *
+	 * @access public
+	 * @param string $class_name
+	 * @return \ReflectionClass
+	 */
+	public function getReflectionClass($class_name);
+
+
+
+	/**
+	 * resolveDependencies
+	 * examines the constructor for the requested class to determine
+	 * if any dependencies exist, and if they can be injected.
+	 * If so, then those classes will be added to the array of arguments passed to the constructor
+	 * PLZ NOTE: this is achieved by type hinting the constructor params
+	 * For example:
+	 *        if attempting to load a class "Foo" with the following constructor:
+	 *        __construct( Bar $bar_class, Fighter $grohl_class )
+	 *        then $bar_class and $grohl_class will be added to the $arguments array,
+	 *        but only IF they are NOT already present in the incoming arguments array,
+	 *        and the correct classes can be loaded
+	 *
+	 * @access public
+	 * @param \EventEspresso\core\services\container\RecipeInterface $recipe
+	 * @param \ReflectionClass                                       $reflector
+	 * @param array                                                  $arguments
+	 * @return array
+	 */
+	public function resolveDependencies(RecipeInterface $recipe, \ReflectionClass $reflector, $arguments = array());
 
 }
 // End of file InjectorInterface.php

core/services/container/SharedCoffeeMaker.php

Indentation +38 added lines, -38 removed lines

@@ -2,7 +2,7 @@ 
 namespace EventEspresso\core\services\container;
 
 if ( ! defined('EVENT_ESPRESSO_VERSION')) {
-    exit('No direct script access allowed');
+	exit('No direct script access allowed');
 }
 
 
@@ -24,46 +24,46 @@ 
 
 
 
-    /**
-     * @return string
-     */
-    public function type()
-    {
-        return CoffeeMaker::BREW_SHARED;
-    }
+	/**
+	 * @return string
+	 */
+	public function type()
+	{
+		return CoffeeMaker::BREW_SHARED;
+	}
 
 
 
-    /**
-     * @param RecipeInterface $recipe
-     * @param array           $arguments
-     * @return mixed
-     */
-    public function brew(RecipeInterface $recipe, $arguments = array())
-    {
-        $this->resolveClassAndFilepath($recipe);
-        $reflector = $this->injector()->getReflectionClass($recipe->fqcn());
-        $method = $this->resolveInstantiationMethod($reflector);
-        switch ($method) {
-            case 'instance' :
-            case 'new_instance' :
-            case 'new_instance_from_db';
-                $service = call_user_func_array(
-                    array($reflector->getName(), $method),
-                    $this->injector()->resolveDependencies($recipe, $reflector, $arguments)
-                );
-                break;
-            case 'newInstance' :
-                $service = $reflector->newInstance();
-                break;
-            case 'newInstanceArgs' :
-            default :
-                $service = $reflector->newInstanceArgs(
-                    $this->injector()->resolveDependencies($recipe, $reflector, $arguments)
-                );
-        }
-        return $this->coffeePot()->addService($recipe->identifier(), $service);
-    }
+	/**
+	 * @param RecipeInterface $recipe
+	 * @param array           $arguments
+	 * @return mixed
+	 */
+	public function brew(RecipeInterface $recipe, $arguments = array())
+	{
+		$this->resolveClassAndFilepath($recipe);
+		$reflector = $this->injector()->getReflectionClass($recipe->fqcn());
+		$method = $this->resolveInstantiationMethod($reflector);
+		switch ($method) {
+			case 'instance' :
+			case 'new_instance' :
+			case 'new_instance_from_db';
+				$service = call_user_func_array(
+					array($reflector->getName(), $method),
+					$this->injector()->resolveDependencies($recipe, $reflector, $arguments)
+				);
+				break;
+			case 'newInstance' :
+				$service = $reflector->newInstance();
+				break;
+			case 'newInstanceArgs' :
+			default :
+				$service = $reflector->newInstanceArgs(
+					$this->injector()->resolveDependencies($recipe, $reflector, $arguments)
+				);
+		}
+		return $this->coffeePot()->addService($recipe->identifier(), $service);
+	}
 
 }
 // End of file SharedCoffeeMaker.php

core/services/container/NewCoffeeMaker.php

Indentation +46 added lines, -46 removed lines

@@ -2,7 +2,7 @@ 
 namespace EventEspresso\core\services\container;
 
 if ( ! defined('EVENT_ESPRESSO_VERSION')) {
-    exit('No direct script access allowed');
+	exit('No direct script access allowed');
 }
 
 
@@ -25,54 +25,54 @@ 
 {
 
 
-    /**
-     * @return string
-     */
-    public function type()
-    {
-        return CoffeeMaker::BREW_NEW;
-    }
+	/**
+	 * @return string
+	 */
+	public function type()
+	{
+		return CoffeeMaker::BREW_NEW;
+	}
 
 
 
-    /**
-     * @param RecipeInterface $recipe
-     * @param array           $arguments
-     * @return mixed
-     */
-    public function brew(RecipeInterface $recipe, $arguments = array())
-    {
-        $this->resolveClassAndFilepath($recipe);
-        $reflector = $this->injector()->getReflectionClass($recipe->fqcn());
-        $method = $this->resolveInstantiationMethod($reflector);
-        switch ($method) {
-            case 'instance' :
-            case 'new_instance' :
-            case 'new_instance_from_db';
-                $injector = $this->injector();
-                $closure = function ($arguments) use ($recipe, $reflector, $method, $injector) {
-                    return call_user_func_array(
-                        array($reflector->getName(), $method),
-                        $injector->resolveDependencies($recipe, $reflector, $arguments)
-                    );
-                };
-                break;
-            case 'newInstance' :
-                $closure = function () use ($reflector) {
-                    return $reflector->newInstance();
-                };
-                break;
-            case 'newInstanceArgs' :
-            default :
-                $injector = $this->injector();
-                $closure = function ($arguments) use ($recipe, $reflector, $injector) {
-                    return $reflector->newInstanceArgs(
-                        $injector->resolveDependencies($recipe, $reflector, $arguments)
-                    );
-                };
-        }
-        return $this->coffeePot()->addClosure($recipe->identifier(), $closure);
-    }
+	/**
+	 * @param RecipeInterface $recipe
+	 * @param array           $arguments
+	 * @return mixed
+	 */
+	public function brew(RecipeInterface $recipe, $arguments = array())
+	{
+		$this->resolveClassAndFilepath($recipe);
+		$reflector = $this->injector()->getReflectionClass($recipe->fqcn());
+		$method = $this->resolveInstantiationMethod($reflector);
+		switch ($method) {
+			case 'instance' :
+			case 'new_instance' :
+			case 'new_instance_from_db';
+				$injector = $this->injector();
+				$closure = function ($arguments) use ($recipe, $reflector, $method, $injector) {
+					return call_user_func_array(
+						array($reflector->getName(), $method),
+						$injector->resolveDependencies($recipe, $reflector, $arguments)
+					);
+				};
+				break;
+			case 'newInstance' :
+				$closure = function () use ($reflector) {
+					return $reflector->newInstance();
+				};
+				break;
+			case 'newInstanceArgs' :
+			default :
+				$injector = $this->injector();
+				$closure = function ($arguments) use ($recipe, $reflector, $injector) {
+					return $reflector->newInstanceArgs(
+						$injector->resolveDependencies($recipe, $reflector, $arguments)
+					);
+				};
+		}
+		return $this->coffeePot()->addClosure($recipe->identifier(), $closure);
+	}
 
 
 }

Spacing +3 added lines, -3 removed lines

@@ -50,7 +50,7 @@ 
             case 'new_instance' :
             case 'new_instance_from_db';
                 $injector = $this->injector();
-                $closure = function ($arguments) use ($recipe, $reflector, $method, $injector) {
+                $closure = function($arguments) use ($recipe, $reflector, $method, $injector) {
                     return call_user_func_array(
                         array($reflector->getName(), $method),
                         $injector->resolveDependencies($recipe, $reflector, $arguments)
@@ -58,14 +58,14 @@ 
                 };
                 break;
             case 'newInstance' :
-                $closure = function () use ($reflector) {
+                $closure = function() use ($reflector) {
                     return $reflector->newInstance();
                 };
                 break;
             case 'newInstanceArgs' :
             default :
                 $injector = $this->injector();
-                $closure = function ($arguments) use ($recipe, $reflector, $injector) {
+                $closure = function($arguments) use ($recipe, $reflector, $injector) {
                     return $reflector->newInstanceArgs(
                         $injector->resolveDependencies($recipe, $reflector, $arguments)
                     );

core/services/container/RecipeInterface.php

Indentation +79 added lines, -79 removed lines

@@ -2,7 +2,7 @@ 
 namespace EventEspresso\core\services\container;
 
 if ( ! defined('EVENT_ESPRESSO_VERSION')) {
-    exit('No direct script access allowed');
+	exit('No direct script access allowed');
 }
 
 
@@ -17,84 +17,84 @@ 
 interface RecipeInterface
 {
 
-    /**
-     * @return string
-     */
-    public function identifier();
-
-    /**
-     * @return string
-     */
-    public function fqcn();
-
-    /**
-     * @return array
-     */
-    public function ingredients();
-
-    /**
-     * @return string
-     */
-    public function type();
-
-    /**
-     * @return array
-     */
-    public function filters();
-
-    /**
-     * @return array
-     */
-    public function paths();
-
-    /**
-     * @param  string $identifier Identifier for the entity class that the Recipe applies to
-     *                            Typically a Fully Qualified Class Name
-     */
-    public function setIdentifier($identifier);
-
-    /**
-     * Ensures incoming string is a valid Fully Qualified Class Name,
-     * except if this is the default wildcard Recipe ( * ),
-     * or it's NOT an actual FQCN because the Recipe is using filepaths
-     * for classes that are not PSR-4 compatible
-     * PLZ NOTE:
-     *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
-     *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
-     *
-     * @param string $fqcn
-     */
-    public function setFqcn($fqcn);
-
-    /**
-     * @param array $ingredients    an array of dependencies where keys are the aliases and values are the FQCNs
-     *                              example:
-     *                              array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
-     */
-    public function setIngredients(array $ingredients);
-
-    /**
-     * @param string $type one of the class constants returned from CoffeeMaker::getTypes()
-     */
-    public function setType($type = CoffeeMaker::BREW_NEW);
-
-    /**
-     * @param array $filters    an array of filters where keys are the aliases and values are the FQCNs
-     *                          example:
-     *                          array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
-     */
-    public function setFilters(array $filters);
-
-    /**
-     * Ensures incoming paths is a valid filepath, or array of valid filepaths,
-     * and merges them in with any existing filepaths
-     * PLZ NOTE:
-     *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
-     *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
-     *
-     * @param string|array $paths
-     */
-    public function setPaths($paths = array());
+	/**
+	 * @return string
+	 */
+	public function identifier();
+
+	/**
+	 * @return string
+	 */
+	public function fqcn();
+
+	/**
+	 * @return array
+	 */
+	public function ingredients();
+
+	/**
+	 * @return string
+	 */
+	public function type();
+
+	/**
+	 * @return array
+	 */
+	public function filters();
+
+	/**
+	 * @return array
+	 */
+	public function paths();
+
+	/**
+	 * @param  string $identifier Identifier for the entity class that the Recipe applies to
+	 *                            Typically a Fully Qualified Class Name
+	 */
+	public function setIdentifier($identifier);
+
+	/**
+	 * Ensures incoming string is a valid Fully Qualified Class Name,
+	 * except if this is the default wildcard Recipe ( * ),
+	 * or it's NOT an actual FQCN because the Recipe is using filepaths
+	 * for classes that are not PSR-4 compatible
+	 * PLZ NOTE:
+	 *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
+	 *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
+	 *
+	 * @param string $fqcn
+	 */
+	public function setFqcn($fqcn);
+
+	/**
+	 * @param array $ingredients    an array of dependencies where keys are the aliases and values are the FQCNs
+	 *                              example:
+	 *                              array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
+	 */
+	public function setIngredients(array $ingredients);
+
+	/**
+	 * @param string $type one of the class constants returned from CoffeeMaker::getTypes()
+	 */
+	public function setType($type = CoffeeMaker::BREW_NEW);
+
+	/**
+	 * @param array $filters    an array of filters where keys are the aliases and values are the FQCNs
+	 *                          example:
+	 *                          array( 'ClassInterface' => 'Fully\Qualified\ClassName' )
+	 */
+	public function setFilters(array $filters);
+
+	/**
+	 * Ensures incoming paths is a valid filepath, or array of valid filepaths,
+	 * and merges them in with any existing filepaths
+	 * PLZ NOTE:
+	 *  Recipe::setFqcn() has a check to see if Recipe::$paths is empty or not,
+	 *  therefore you should always call Recipe::setPaths() before Recipe::setFqcn()
+	 *
+	 * @param string|array $paths
+	 */
+	public function setPaths($paths = array());
 
 }
 // End of file RecipeInterface.php

core/domain/services/capabilities/CapCheck.php

Doc Comments +1 added lines, -1 removed lines

@@ -38,7 +38,7 @@
 
 
     /**
-     * @param string|array $capability - the capability to be checked, like: 'ee_edit_registrations',
+     * @param string $capability - the capability to be checked, like: 'ee_edit_registrations',
      *                                   or an array of capability strings
      * @param string       $context    - what the user is attempting to do, like: 'Edit Registration'
      * @param int          $ID         - (optional) ID for item where current_user_can is being called from

Indentation +66 added lines, -66 removed lines

@@ -4,7 +4,7 @@ 
 use EventEspresso\core\exceptions\InvalidDataTypeException;
 
 if ( ! defined('EVENT_ESPRESSO_VERSION')) {
-    exit('No direct script access allowed');
+	exit('No direct script access allowed');
 }
 
 
@@ -20,71 +20,71 @@ 
 class CapCheck implements CapCheckInterface
 {
 
-    /**
-     * @var string|array $capability
-     */
-    private $capability;
-
-    /**
-     * @var string $context
-     */
-    private $context;
-
-    /**
-     * @var int|string $ID
-     */
-    private $ID;
-
-
-
-    /**
-     * @param string|array $capability - the capability to be checked, like: 'ee_edit_registrations',
-     *                                   or an array of capability strings
-     * @param string       $context    - what the user is attempting to do, like: 'Edit Registration'
-     * @param int          $ID         - (optional) ID for item where current_user_can is being called from
-     */
-    public function __construct($capability, $context, $ID = 0)
-    {
-        if ( ! is_string($capability)) {
-            throw new InvalidDataTypeException('$capability', $capability, 'string');
-        }
-        if ( ! is_string($context)) {
-            throw new InvalidDataTypeException('$context', $context, 'string');
-        }
-        $this->capability = $capability;
-        $this->context = strtolower(str_replace(' ', '_', $context));
-        $this->ID = $ID;
-    }
-
-
-
-    /**
-     * @return string|array
-     */
-    public function capability()
-    {
-        return $this->capability;
-    }
-
-
-
-    /**
-     * @return string
-     */
-    public function context()
-    {
-        return $this->context;
-    }
-
-
-
-    /**
-     * @return int|string
-     */
-    public function ID()
-    {
-        return $this->ID;
-    }
+	/**
+	 * @var string|array $capability
+	 */
+	private $capability;
+
+	/**
+	 * @var string $context
+	 */
+	private $context;
+
+	/**
+	 * @var int|string $ID
+	 */
+	private $ID;
+
+
+
+	/**
+	 * @param string|array $capability - the capability to be checked, like: 'ee_edit_registrations',
+	 *                                   or an array of capability strings
+	 * @param string       $context    - what the user is attempting to do, like: 'Edit Registration'
+	 * @param int          $ID         - (optional) ID for item where current_user_can is being called from
+	 */
+	public function __construct($capability, $context, $ID = 0)
+	{
+		if ( ! is_string($capability)) {
+			throw new InvalidDataTypeException('$capability', $capability, 'string');
+		}
+		if ( ! is_string($context)) {
+			throw new InvalidDataTypeException('$context', $context, 'string');
+		}
+		$this->capability = $capability;
+		$this->context = strtolower(str_replace(' ', '_', $context));
+		$this->ID = $ID;
+	}
+
+
+
+	/**
+	 * @return string|array
+	 */
+	public function capability()
+	{
+		return $this->capability;
+	}
+
+
+
+	/**
+	 * @return string
+	 */
+	public function context()
+	{
+		return $this->context;
+	}
+
+
+
+	/**
+	 * @return int|string
+	 */
+	public function ID()
+	{
+		return $this->ID;
+	}
 
 
 }

core/EE_Network_Config.core.php

Spacing +32 added lines, -32 removed lines

@@ -58,7 +58,7 @@ 
 	 */
 	public static function instance() {
 		// check if class object is instantiated, and instantiated properly
-		if ( self::$_instance === NULL  or ! is_object( self::$_instance ) or ! ( self::$_instance instanceof EE_Network_Config )) {
+		if (self::$_instance === NULL or ! is_object(self::$_instance) or ! (self::$_instance instanceof EE_Network_Config)) {
 			self::$_instance = new self();
 		}
 		return self::$_instance;
@@ -73,15 +73,15 @@ 
 	 *  @access 	private
 	 */
 	private function __construct() {
-		do_action( 'AHEE__EE_Network_Config__construct__begin',$this );
+		do_action('AHEE__EE_Network_Config__construct__begin', $this);
 		//set defaults
-		$this->core = apply_filters( 'FHEE__EE_Network_Config___construct__core', new EE_Network_Core_Config() );
+		$this->core = apply_filters('FHEE__EE_Network_Config___construct__core', new EE_Network_Core_Config());
 		$this->addons = array();
 
 		$this->_load_config();
 
 		// construct__end hook
-		do_action( 'AHEE__EE_Network_Config__construct__end',$this );
+		do_action('AHEE__EE_Network_Config__construct__end', $this);
 	}
 
 
@@ -94,25 +94,25 @@ 
 	 */
 	private function _load_config() {
 		//load network config start hook
-		do_action( 'AHEE__EE_Network_Config___load_config__start', $this );
+		do_action('AHEE__EE_Network_Config___load_config__start', $this);
 		$config = $this->get_config();
-		foreach ( $config as $config_prop => $settings ) {
-			if ( is_object( $settings ) && property_exists( $this, $config_prop ) ) {
-				$this->{$config_prop} = apply_filters( 'FHEE__EE_Network_Config___load_config__config_settings', $settings, $config_prop, $this );
-				if ( method_exists( $settings, 'populate' ) ) {
+		foreach ($config as $config_prop => $settings) {
+			if (is_object($settings) && property_exists($this, $config_prop)) {
+				$this->{$config_prop} = apply_filters('FHEE__EE_Network_Config___load_config__config_settings', $settings, $config_prop, $this);
+				if (method_exists($settings, 'populate')) {
 					$this->{$config_prop}->populate();
 				}
-				if ( method_exists( $settings, 'do_hooks' ) ) {
+				if (method_exists($settings, 'do_hooks')) {
 					$this->{$config_prop}->do_hooks();
 				}
 			}
 		}
-		if ( apply_filters( 'FHEE__EE_Network_Config___load_config__update_network_config', false ) ) {
+		if (apply_filters('FHEE__EE_Network_Config___load_config__update_network_config', false)) {
 			$this->update_config();
 		}
 
 		//load network config end hook
-		do_action( 'AHEE__EE_Network_Config___load_config__end', $this );
+		do_action('AHEE__EE_Network_Config___load_config__end', $this);
 	}
 
 
@@ -126,8 +126,8 @@ 
 	 */
 	public function get_config() {
 		// grab network configuration
-		$CFG = get_site_option( 'ee_network_config', array() );
-		$CFG = apply_filters( 'FHEE__EE_Network_Config__get_config__CFG', $CFG );
+		$CFG = get_site_option('ee_network_config', array());
+		$CFG = apply_filters('FHEE__EE_Network_Config__get_config__CFG', $CFG);
 		return $CFG;
 	}
 
@@ -141,39 +141,39 @@ 
 	 * @param bool $add_error
 	 * @return bool success
 	 */
-	public function update_config( $add_success = FALSE, $add_error = TRUE ) {
-		do_action( 'AHEE__EE_Network_Config__update_config__begin',$this );
+	public function update_config($add_success = FALSE, $add_error = TRUE) {
+		do_action('AHEE__EE_Network_Config__update_config__begin', $this);
 
 		//need to bust cache for comparing original if this is a multisite install
-		if ( is_multisite() ) {
+		if (is_multisite()) {
 			global $current_site;
-			$cache_key = $current_site->id . ':ee_network_config';
-			wp_cache_delete( $cache_key, 'site-options' );
+			$cache_key = $current_site->id.':ee_network_config';
+			wp_cache_delete($cache_key, 'site-options');
 		}
 
 		//we have to compare existing saved config with config in memory because if there is no difference that means
 		//that the method executed fine but there just was no update.  WordPress doesn't distinguish between false because
 		//there were 0 records updated because of no change vs false because some error produced problems with the update.
-		$original = get_site_option( 'ee_network_config' );
+		$original = get_site_option('ee_network_config');
 
-		if ( $original == $this ) {
+		if ($original == $this) {
 			return true;
 		}
 		// update
-		$saved = update_site_option( 'ee_network_config', $this );
+		$saved = update_site_option('ee_network_config', $this);
 
-		do_action( 'AHEE__EE_Network_Config__update_config__end', $this, $saved );
+		do_action('AHEE__EE_Network_Config__update_config__end', $this, $saved);
 		// if config remains the same or was updated successfully
-		if ( $saved ) {
-			if ( $add_success ) {
-				$msg = is_multisite() ? __( 'The Event Espresso Network Configuration Settings have been successfully updated.', 'event_espresso' ) : __( 'Extra Event Espresso Configuration settings were successfully updated.', 'event_espresso' );
-				EE_Error::add_success( $msg );
+		if ($saved) {
+			if ($add_success) {
+				$msg = is_multisite() ? __('The Event Espresso Network Configuration Settings have been successfully updated.', 'event_espresso') : __('Extra Event Espresso Configuration settings were successfully updated.', 'event_espresso');
+				EE_Error::add_success($msg);
 			}
 			return true;
 		} else {
-			if ( $add_error ) {
-				$msg = is_multisite() ? __( 'The Event Espresso Network Configuration Settings were not updated.', 'event_espresso' ) : __( 'Extra Event Espresso Network Configuration settings were not updated.', 'event_espresso' );
-				EE_Error::add_error( $msg , __FILE__, __FUNCTION__, __LINE__ );
+			if ($add_error) {
+				$msg = is_multisite() ? __('The Event Espresso Network Configuration Settings were not updated.', 'event_espresso') : __('Extra Event Espresso Network Configuration settings were not updated.', 'event_espresso');
+				EE_Error::add_error($msg, __FILE__, __FUNCTION__, __LINE__);
 			}
 			return false;
 		}
@@ -187,9 +187,9 @@ 
 	 *  @return 	array
 	 */
 	public function __sleep() {
-		return apply_filters( 'FHEE__EE_Network_Config__sleep',array(
+		return apply_filters('FHEE__EE_Network_Config__sleep', array(
 			'core',
-		) );
+		));
 	}
 
 } //end EE_Network_Config.