iqltechnologies / brighty

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/ManifestGenerator.php

Indentation +71 added lines, -71 removed lines

@@ -20,93 +20,93 @@ 
  */
 class ManifestGenerator {
 
-	/**
-	 * Builds a manifest file for the given autoloader type.
-	 *
-	 * @param string $autoloaderType The type of autoloader to build a manifest for.
-	 * @param string $fileName The filename of the manifest.
-	 * @param array  $content The manifest content to generate using.
-	 *
-	 * @return string|null $manifestFile
-	 * @throws \InvalidArgumentException When an invalid autoloader type is given.
-	 */
-	public static function buildManifest( $autoloaderType, $fileName, $content ) {
-		if ( empty( $content ) ) {
-			return null;
-		}
+    /**
+     * Builds a manifest file for the given autoloader type.
+     *
+     * @param string $autoloaderType The type of autoloader to build a manifest for.
+     * @param string $fileName The filename of the manifest.
+     * @param array  $content The manifest content to generate using.
+     *
+     * @return string|null $manifestFile
+     * @throws \InvalidArgumentException When an invalid autoloader type is given.
+     */
+    public static function buildManifest( $autoloaderType, $fileName, $content ) {
+        if ( empty( $content ) ) {
+            return null;
+        }
 
-		switch ( $autoloaderType ) {
-			case 'classmap':
-			case 'files':
-				return self::buildStandardManifest( $fileName, $content );
-			case 'psr-4':
-				return self::buildPsr4Manifest( $fileName, $content );
-		}
+        switch ( $autoloaderType ) {
+            case 'classmap':
+            case 'files':
+                return self::buildStandardManifest( $fileName, $content );
+            case 'psr-4':
+                return self::buildPsr4Manifest( $fileName, $content );
+        }
 
-		throw new \InvalidArgumentException( 'An invalid manifest type of ' . $autoloaderType . ' was passed!' );
-	}
+        throw new \InvalidArgumentException( 'An invalid manifest type of ' . $autoloaderType . ' was passed!' );
+    }
 
-	/**
-	 * Builds the contents for the standard manifest file.
-	 *
-	 * @param string $fileName The filename we are building.
-	 * @param array  $manifestData The formatted data for the manifest.
-	 *
-	 * @return string|null $manifestFile
-	 */
-	private static function buildStandardManifest( $fileName, $manifestData ) {
-		$fileContent = PHP_EOL;
-		foreach ( $manifestData as $key => $data ) {
-			$key          = var_export( $key, true );
-			$versionCode  = var_export( $data['version'], true );
-			$fileContent .= <<<MANIFEST_CODE
+    /**
+     * Builds the contents for the standard manifest file.
+     *
+     * @param string $fileName The filename we are building.
+     * @param array  $manifestData The formatted data for the manifest.
+     *
+     * @return string|null $manifestFile
+     */
+    private static function buildStandardManifest( $fileName, $manifestData ) {
+        $fileContent = PHP_EOL;
+        foreach ( $manifestData as $key => $data ) {
+            $key          = var_export( $key, true );
+            $versionCode  = var_export( $data['version'], true );
+            $fileContent .= <<<MANIFEST_CODE
 	$key => array(
 		'version' => $versionCode,
 		'path'    => {$data['path']}
 	),
 MANIFEST_CODE;
-			$fileContent .= PHP_EOL;
-		}
+            $fileContent .= PHP_EOL;
+        }
 
-		return self::buildFile( $fileName, $fileContent );
-	}
+        return self::buildFile( $fileName, $fileContent );
+    }
 
-	/**
-	 * Builds the contents for the PSR-4 manifest file.
-	 *
-	 * @param string $fileName The filename we are building.
-	 * @param array  $namespaces The formatted PSR-4 data for the manifest.
-	 *
-	 * @return string|null $manifestFile
-	 */
-	private static function buildPsr4Manifest( $fileName, $namespaces ) {
-		$fileContent = PHP_EOL;
-		foreach ( $namespaces as $namespace => $data ) {
-			$namespaceCode = var_export( $namespace, true );
-			$versionCode   = var_export( $data['version'], true );
-			$pathCode      = 'array( ' . implode( ', ', $data['path'] ) . ' )';
-			$fileContent  .= <<<MANIFEST_CODE
+    /**
+     * Builds the contents for the PSR-4 manifest file.
+     *
+     * @param string $fileName The filename we are building.
+     * @param array  $namespaces The formatted PSR-4 data for the manifest.
+     *
+     * @return string|null $manifestFile
+     */
+    private static function buildPsr4Manifest( $fileName, $namespaces ) {
+        $fileContent = PHP_EOL;
+        foreach ( $namespaces as $namespace => $data ) {
+            $namespaceCode = var_export( $namespace, true );
+            $versionCode   = var_export( $data['version'], true );
+            $pathCode      = 'array( ' . implode( ', ', $data['path'] ) . ' )';
+            $fileContent  .= <<<MANIFEST_CODE
 	$namespaceCode => array(
 		'version' => $versionCode,
 		'path'    => $pathCode
 	),
 MANIFEST_CODE;
-			$fileContent  .= PHP_EOL;
-		}
+            $fileContent  .= PHP_EOL;
+        }
 
-		return self::buildFile( $fileName, $fileContent );
-	}
+        return self::buildFile( $fileName, $fileContent );
+    }
 
-	/**
-	 * Generate the PHP that will be used in the file.
-	 *
-	 * @param string $fileName The filename we are building.
-	 * @param string $content The content to be written into the file.
-	 *
-	 * @return string $fileContent
-	 */
-	private static function buildFile( $fileName, $content ) {
-		return <<<INCLUDE_FILE
+    /**
+     * Generate the PHP that will be used in the file.
+     *
+     * @param string $fileName The filename we are building.
+     * @param string $content The content to be written into the file.
+     *
+     * @return string $fileContent
+     */
+    private static function buildFile( $fileName, $content ) {
+        return <<<INCLUDE_FILE
 <?php
 
 // This file `$fileName` was auto generated by automattic/jetpack-autoloader.
@@ -117,5 +117,5 @@ 
 return array($content);
 
 INCLUDE_FILE;
-	}
+    }
 }

Spacing +19 added lines, -19 removed lines

@@ -30,20 +30,20 @@ 
 	 * @return string|null $manifestFile
 	 * @throws \InvalidArgumentException When an invalid autoloader type is given.
 	 */
-	public static function buildManifest( $autoloaderType, $fileName, $content ) {
-		if ( empty( $content ) ) {
+	public static function buildManifest($autoloaderType, $fileName, $content) {
+		if (empty($content)) {
 			return null;
 		}
 
-		switch ( $autoloaderType ) {
+		switch ($autoloaderType) {
 			case 'classmap':
 			case 'files':
-				return self::buildStandardManifest( $fileName, $content );
+				return self::buildStandardManifest($fileName, $content);
 			case 'psr-4':
-				return self::buildPsr4Manifest( $fileName, $content );
+				return self::buildPsr4Manifest($fileName, $content);
 		}
 
-		throw new \InvalidArgumentException( 'An invalid manifest type of ' . $autoloaderType . ' was passed!' );
+		throw new \InvalidArgumentException('An invalid manifest type of ' . $autoloaderType . ' was passed!');
 	}
 
 	/**
@@ -54,11 +54,11 @@ 
 	 *
 	 * @return string|null $manifestFile
 	 */
-	private static function buildStandardManifest( $fileName, $manifestData ) {
+	private static function buildStandardManifest($fileName, $manifestData) {
 		$fileContent = PHP_EOL;
-		foreach ( $manifestData as $key => $data ) {
-			$key          = var_export( $key, true );
-			$versionCode  = var_export( $data['version'], true );
+		foreach ($manifestData as $key => $data) {
+			$key          = var_export($key, true);
+			$versionCode  = var_export($data['version'], true);
 			$fileContent .= <<<MANIFEST_CODE
 	$key => array(
 		'version' => $versionCode,
@@ -68,7 +68,7 @@ 
 			$fileContent .= PHP_EOL;
 		}
 
-		return self::buildFile( $fileName, $fileContent );
+		return self::buildFile($fileName, $fileContent);
 	}
 
 	/**
@@ -79,22 +79,22 @@ 
 	 *
 	 * @return string|null $manifestFile
 	 */
-	private static function buildPsr4Manifest( $fileName, $namespaces ) {
+	private static function buildPsr4Manifest($fileName, $namespaces) {
 		$fileContent = PHP_EOL;
-		foreach ( $namespaces as $namespace => $data ) {
-			$namespaceCode = var_export( $namespace, true );
-			$versionCode   = var_export( $data['version'], true );
-			$pathCode      = 'array( ' . implode( ', ', $data['path'] ) . ' )';
+		foreach ($namespaces as $namespace => $data) {
+			$namespaceCode = var_export($namespace, true);
+			$versionCode   = var_export($data['version'], true);
+			$pathCode      = 'array( ' . implode(', ', $data['path']) . ' )';
 			$fileContent  .= <<<MANIFEST_CODE
 	$namespaceCode => array(
 		'version' => $versionCode,
 		'path'    => $pathCode
 	),
 MANIFEST_CODE;
-			$fileContent  .= PHP_EOL;
+			$fileContent .= PHP_EOL;
 		}
 
-		return self::buildFile( $fileName, $fileContent );
+		return self::buildFile($fileName, $fileContent);
 	}
 
 	/**
@@ -105,7 +105,7 @@ 
 	 *
 	 * @return string $fileContent
 	 */
-	private static function buildFile( $fileName, $content ) {
+	private static function buildFile($fileName, $content) {
 		return <<<INCLUDE_FILE
 <?php
 

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/class-php-autoloader.php

Indentation +64 added lines, -64 removed lines

@@ -6,77 +6,77 @@
  */
 class PHP_Autoloader {
 
-	/**
-	 * Registers the autoloader with PHP so that it can begin autoloading classes.
-	 *
-	 * @param Version_Loader $version_loader The class loader to use in the autoloader.
-	 */
-	public function register_autoloader( $version_loader ) {
-		// Make sure no other autoloaders are registered.
-		$this->unregister_autoloader();
+    /**
+     * Registers the autoloader with PHP so that it can begin autoloading classes.
+     *
+     * @param Version_Loader $version_loader The class loader to use in the autoloader.
+     */
+    public function register_autoloader( $version_loader ) {
+        // Make sure no other autoloaders are registered.
+        $this->unregister_autoloader();
 
-		// Set the global so that it can be used to load classes.
-		global $jetpack_autoloader_loader;
-		$jetpack_autoloader_loader = $version_loader;
+        // Set the global so that it can be used to load classes.
+        global $jetpack_autoloader_loader;
+        $jetpack_autoloader_loader = $version_loader;
 
-		// Ensure that the autoloader is first to avoid contention with others.
-		spl_autoload_register( array( self::class, 'load_class' ), true, true );
-	}
+        // Ensure that the autoloader is first to avoid contention with others.
+        spl_autoload_register( array( self::class, 'load_class' ), true, true );
+    }
 
-	/**
-	 * Unregisters the active autoloader so that it will no longer autoload classes.
-	 */
-	public function unregister_autoloader() {
-		// Remove any v2 autoloader that we've already registered.
-		$autoload_chain = spl_autoload_functions();
-		foreach ( $autoload_chain as $autoloader ) {
-			// We can identify a v2 autoloader using the namespace.
-			$namespace_check = null;
+    /**
+     * Unregisters the active autoloader so that it will no longer autoload classes.
+     */
+    public function unregister_autoloader() {
+        // Remove any v2 autoloader that we've already registered.
+        $autoload_chain = spl_autoload_functions();
+        foreach ( $autoload_chain as $autoloader ) {
+            // We can identify a v2 autoloader using the namespace.
+            $namespace_check = null;
 
-			// Functions are recorded as strings.
-			if ( is_string( $autoloader ) ) {
-				$namespace_check = $autoloader;
-			} elseif ( is_array( $autoloader ) && is_string( $autoloader[0] ) ) {
-				// Static method calls have the class as the first array element.
-				$namespace_check = $autoloader[0];
-			} else {
-				// Since the autoloader has only ever been a function or a static method we don't currently need to check anything else.
-				continue;
-			}
+            // Functions are recorded as strings.
+            if ( is_string( $autoloader ) ) {
+                $namespace_check = $autoloader;
+            } elseif ( is_array( $autoloader ) && is_string( $autoloader[0] ) ) {
+                // Static method calls have the class as the first array element.
+                $namespace_check = $autoloader[0];
+            } else {
+                // Since the autoloader has only ever been a function or a static method we don't currently need to check anything else.
+                continue;
+            }
 
-			// Check for the namespace without the generated suffix.
-			if ( 'Automattic\\Jetpack\\Autoloader\\jp' === substr( $namespace_check, 0, 32 ) ) {
-				spl_autoload_unregister( $autoloader );
-			}
-		}
+            // Check for the namespace without the generated suffix.
+            if ( 'Automattic\\Jetpack\\Autoloader\\jp' === substr( $namespace_check, 0, 32 ) ) {
+                spl_autoload_unregister( $autoloader );
+            }
+        }
 
-		// Clear the global now that the autoloader has been unregistered.
-		global $jetpack_autoloader_loader;
-		$jetpack_autoloader_loader = null;
-	}
+        // Clear the global now that the autoloader has been unregistered.
+        global $jetpack_autoloader_loader;
+        $jetpack_autoloader_loader = null;
+    }
 
-	/**
-	 * Loads a class file if one could be found.
-	 *
-	 * Note: This function is static so that the autoloader can be easily unregistered. If
-	 * it was a class method we would have to unwrap the object to check the namespace.
-	 *
-	 * @param string $class_name The name of the class to autoload.
-	 *
-	 * @return bool Indicates whether or not a class file was loaded.
-	 */
-	public static function load_class( $class_name ) {
-		global $jetpack_autoloader_loader;
-		if ( ! isset( $jetpack_autoloader_loader ) ) {
-			return;
-		}
+    /**
+     * Loads a class file if one could be found.
+     *
+     * Note: This function is static so that the autoloader can be easily unregistered. If
+     * it was a class method we would have to unwrap the object to check the namespace.
+     *
+     * @param string $class_name The name of the class to autoload.
+     *
+     * @return bool Indicates whether or not a class file was loaded.
+     */
+    public static function load_class( $class_name ) {
+        global $jetpack_autoloader_loader;
+        if ( ! isset( $jetpack_autoloader_loader ) ) {
+            return;
+        }
 
-		$file = $jetpack_autoloader_loader->find_class_file( $class_name );
-		if ( ! isset( $file ) ) {
-			return false;
-		}
+        $file = $jetpack_autoloader_loader->find_class_file( $class_name );
+        if ( ! isset( $file ) ) {
+            return false;
+        }
 
-		require $file;
-		return true;
-	}
+        require $file;
+        return true;
+    }
 }

Spacing +11 added lines, -11 removed lines

@@ -11,7 +11,7 @@ 
 	 *
 	 * @param Version_Loader $version_loader The class loader to use in the autoloader.
 	 */
-	public function register_autoloader( $version_loader ) {
+	public function register_autoloader($version_loader) {
 		// Make sure no other autoloaders are registered.
 		$this->unregister_autoloader();
 
@@ -20,7 +20,7 @@ 
 		$jetpack_autoloader_loader = $version_loader;
 
 		// Ensure that the autoloader is first to avoid contention with others.
-		spl_autoload_register( array( self::class, 'load_class' ), true, true );
+		spl_autoload_register(array(self::class, 'load_class'), true, true);
 	}
 
 	/**
@@ -29,14 +29,14 @@ 
 	public function unregister_autoloader() {
 		// Remove any v2 autoloader that we've already registered.
 		$autoload_chain = spl_autoload_functions();
-		foreach ( $autoload_chain as $autoloader ) {
+		foreach ($autoload_chain as $autoloader) {
 			// We can identify a v2 autoloader using the namespace.
 			$namespace_check = null;
 
 			// Functions are recorded as strings.
-			if ( is_string( $autoloader ) ) {
+			if (is_string($autoloader)) {
 				$namespace_check = $autoloader;
-			} elseif ( is_array( $autoloader ) && is_string( $autoloader[0] ) ) {
+			} elseif (is_array($autoloader) && is_string($autoloader[0])) {
 				// Static method calls have the class as the first array element.
 				$namespace_check = $autoloader[0];
 			} else {
@@ -45,8 +45,8 @@ 
 			}
 
 			// Check for the namespace without the generated suffix.
-			if ( 'Automattic\\Jetpack\\Autoloader\\jp' === substr( $namespace_check, 0, 32 ) ) {
-				spl_autoload_unregister( $autoloader );
+			if ('Automattic\\Jetpack\\Autoloader\\jp' === substr($namespace_check, 0, 32)) {
+				spl_autoload_unregister($autoloader);
 			}
 		}
 
@@ -65,14 +65,14 @@ 
 	 *
 	 * @return bool Indicates whether or not a class file was loaded.
 	 */
-	public static function load_class( $class_name ) {
+	public static function load_class($class_name) {
 		global $jetpack_autoloader_loader;
-		if ( ! isset( $jetpack_autoloader_loader ) ) {
+		if (!isset($jetpack_autoloader_loader)) {
 			return;
 		}
 
-		$file = $jetpack_autoloader_loader->find_class_file( $class_name );
-		if ( ! isset( $file ) ) {
+		$file = $jetpack_autoloader_loader->find_class_file($class_name);
+		if (!isset($file)) {
 			return false;
 		}
 

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/class-shutdown-handler.php

Indentation +66 added lines, -66 removed lines

@@ -6,79 +6,79 @@
  */
 class Shutdown_Handler {
 
-	/**
-	 * The Plugins_Handler instance.
-	 *
-	 * @var Plugins_Handler
-	 */
-	private $plugins_handler;
+    /**
+     * The Plugins_Handler instance.
+     *
+     * @var Plugins_Handler
+     */
+    private $plugins_handler;
 
-	/**
-	 * The plugins cached by this autoloader.
-	 *
-	 * @var string[]
-	 */
-	private $cached_plugins;
+    /**
+     * The plugins cached by this autoloader.
+     *
+     * @var string[]
+     */
+    private $cached_plugins;
 
-	/**
-	 * Indicates whether or not this autoloader was included by another.
-	 *
-	 * @var bool
-	 */
-	private $was_included_by_autoloader;
+    /**
+     * Indicates whether or not this autoloader was included by another.
+     *
+     * @var bool
+     */
+    private $was_included_by_autoloader;
 
-	/**
-	 * Constructor.
-	 *
-	 * @param Plugins_Handler $plugins_handler The Plugins_Handler instance to use.
-	 * @param string[]        $cached_plugins The plugins cached by the autoloaer.
-	 * @param bool            $was_included_by_autoloader Indicates whether or not the autoloader was included by another.
-	 */
-	public function __construct( $plugins_handler, $cached_plugins, $was_included_by_autoloader ) {
-		$this->plugins_handler            = $plugins_handler;
-		$this->cached_plugins             = $cached_plugins;
-		$this->was_included_by_autoloader = $was_included_by_autoloader;
-	}
+    /**
+     * Constructor.
+     *
+     * @param Plugins_Handler $plugins_handler The Plugins_Handler instance to use.
+     * @param string[]        $cached_plugins The plugins cached by the autoloaer.
+     * @param bool            $was_included_by_autoloader Indicates whether or not the autoloader was included by another.
+     */
+    public function __construct( $plugins_handler, $cached_plugins, $was_included_by_autoloader ) {
+        $this->plugins_handler            = $plugins_handler;
+        $this->cached_plugins             = $cached_plugins;
+        $this->was_included_by_autoloader = $was_included_by_autoloader;
+    }
 
-	/**
-	 * Handles the shutdown of the autoloader.
-	 */
-	public function __invoke() {
-		// Don't save a broken cache if an error happens during some plugin's initialization.
-		if ( ! did_action( 'plugins_loaded' ) ) {
-			// Ensure that the cache is emptied to prevent consecutive failures if the cache is to blame.
-			if ( ! empty( $this->cached_plugins ) ) {
-				$this->plugins_handler->cache_plugins( array() );
-			}
+    /**
+     * Handles the shutdown of the autoloader.
+     */
+    public function __invoke() {
+        // Don't save a broken cache if an error happens during some plugin's initialization.
+        if ( ! did_action( 'plugins_loaded' ) ) {
+            // Ensure that the cache is emptied to prevent consecutive failures if the cache is to blame.
+            if ( ! empty( $this->cached_plugins ) ) {
+                $this->plugins_handler->cache_plugins( array() );
+            }
 
-			return;
-		}
+            return;
+        }
 
-		// Load the active plugins fresh since the list we pulled earlier might not contain
-		// plugins that were activated but did not reset the autoloader. This happens
-		// when a plugin is in the cache but not "active" when the autoloader loads.
-		// We also want to make sure that plugins which are deactivating are not
-		// considered "active" so that they will be removed from the cache now.
-		try {
-			$active_plugins = $this->plugins_handler->get_active_plugins( false, ! $this->was_included_by_autoloader );
-		} catch ( \Exception $ex ) {
-			// When the package is deleted before shutdown it will throw an exception.
-			// In the event this happens we should erase the cache.
-			if ( ! empty( $this->cached_plugins ) ) {
-				$this->plugins_handler->cache_plugins( array() );
-			}
-			return;
-		}
+        // Load the active plugins fresh since the list we pulled earlier might not contain
+        // plugins that were activated but did not reset the autoloader. This happens
+        // when a plugin is in the cache but not "active" when the autoloader loads.
+        // We also want to make sure that plugins which are deactivating are not
+        // considered "active" so that they will be removed from the cache now.
+        try {
+            $active_plugins = $this->plugins_handler->get_active_plugins( false, ! $this->was_included_by_autoloader );
+        } catch ( \Exception $ex ) {
+            // When the package is deleted before shutdown it will throw an exception.
+            // In the event this happens we should erase the cache.
+            if ( ! empty( $this->cached_plugins ) ) {
+                $this->plugins_handler->cache_plugins( array() );
+            }
+            return;
+        }
 
-		// The paths should be sorted for easy comparisons with those loaded from the cache.
-		// Note we don't need to sort the cached entries because they're already sorted.
-		sort( $active_plugins );
+        // The paths should be sorted for easy comparisons with those loaded from the cache.
+        // Note we don't need to sort the cached entries because they're already sorted.
+        sort( $active_plugins );
 
-		// We don't want to waste time saving a cache that hasn't changed.
-		if ( $this->cached_plugins === $active_plugins ) {
-			return;
-		}
+        // We don't want to waste time saving a cache that hasn't changed.
+        if ( $this->cached_plugins === $active_plugins ) {
+            return;
+        }
 
-		$this->plugins_handler->cache_plugins( $active_plugins );
-	}
+        $this->plugins_handler->cache_plugins( $active_plugins );
+    }
 }

Spacing +11 added lines, -11 removed lines

@@ -34,7 +34,7 @@ 
 	 * @param string[]        $cached_plugins The plugins cached by the autoloaer.
 	 * @param bool            $was_included_by_autoloader Indicates whether or not the autoloader was included by another.
 	 */
-	public function __construct( $plugins_handler, $cached_plugins, $was_included_by_autoloader ) {
+	public function __construct($plugins_handler, $cached_plugins, $was_included_by_autoloader) {
 		$this->plugins_handler            = $plugins_handler;
 		$this->cached_plugins             = $cached_plugins;
 		$this->was_included_by_autoloader = $was_included_by_autoloader;
@@ -45,10 +45,10 @@ 
 	 */
 	public function __invoke() {
 		// Don't save a broken cache if an error happens during some plugin's initialization.
-		if ( ! did_action( 'plugins_loaded' ) ) {
+		if (!did_action('plugins_loaded')) {
 			// Ensure that the cache is emptied to prevent consecutive failures if the cache is to blame.
-			if ( ! empty( $this->cached_plugins ) ) {
-				$this->plugins_handler->cache_plugins( array() );
+			if (!empty($this->cached_plugins)) {
+				$this->plugins_handler->cache_plugins(array());
 			}
 
 			return;
@@ -60,25 +60,25 @@ 
 		// We also want to make sure that plugins which are deactivating are not
 		// considered "active" so that they will be removed from the cache now.
 		try {
-			$active_plugins = $this->plugins_handler->get_active_plugins( false, ! $this->was_included_by_autoloader );
-		} catch ( \Exception $ex ) {
+			$active_plugins = $this->plugins_handler->get_active_plugins(false, !$this->was_included_by_autoloader);
+		} catch (\Exception $ex) {
 			// When the package is deleted before shutdown it will throw an exception.
 			// In the event this happens we should erase the cache.
-			if ( ! empty( $this->cached_plugins ) ) {
-				$this->plugins_handler->cache_plugins( array() );
+			if (!empty($this->cached_plugins)) {
+				$this->plugins_handler->cache_plugins(array());
 			}
 			return;
 		}
 
 		// The paths should be sorted for easy comparisons with those loaded from the cache.
 		// Note we don't need to sort the cached entries because they're already sorted.
-		sort( $active_plugins );
+		sort($active_plugins);
 
 		// We don't want to waste time saving a cache that hasn't changed.
-		if ( $this->cached_plugins === $active_plugins ) {
+		if ($this->cached_plugins === $active_plugins) {
 			return;
 		}
 
-		$this->plugins_handler->cache_plugins( $active_plugins );
+		$this->plugins_handler->cache_plugins($active_plugins);
 	}
 }

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/class-autoloader-handler.php

Indentation +128 added lines, -128 removed lines

@@ -8,132 +8,132 @@
  */
 class Autoloader_Handler {
 
-	/**
-	 * The PHP_Autoloader instance.
-	 *
-	 * @var PHP_Autoloader
-	 */
-	private $php_autoloader;
-
-	/**
-	 * The Hook_Manager instance.
-	 *
-	 * @var Hook_Manager
-	 */
-	private $hook_manager;
-
-	/**
-	 * The Manifest_Reader instance.
-	 *
-	 * @var Manifest_Reader
-	 */
-	private $manifest_reader;
-
-	/**
-	 * The Version_Selector instance.
-	 *
-	 * @var Version_Selector
-	 */
-	private $version_selector;
-
-	/**
-	 * The constructor.
-	 *
-	 * @param PHP_Autoloader   $php_autoloader The PHP_Autoloader instance.
-	 * @param Hook_Manager     $hook_manager The Hook_Manager instance.
-	 * @param Manifest_Reader  $manifest_reader The Manifest_Reader instance.
-	 * @param Version_Selector $version_selector The Version_Selector instance.
-	 */
-	public function __construct( $php_autoloader, $hook_manager, $manifest_reader, $version_selector ) {
-		$this->php_autoloader   = $php_autoloader;
-		$this->hook_manager     = $hook_manager;
-		$this->manifest_reader  = $manifest_reader;
-		$this->version_selector = $version_selector;
-	}
-
-	/**
-	 * Checks to see whether or not an autoloader is currently in the process of initializing.
-	 *
-	 * @return bool
-	 */
-	public function is_initializing() {
-		// If no version has been set it means that no autoloader has started initializing yet.
-		global $jetpack_autoloader_latest_version;
-		if ( ! isset( $jetpack_autoloader_latest_version ) ) {
-			return false;
-		}
-
-		// When the version is set but the classmap is not it ALWAYS means that this is the
-		// latest autoloader and is being included by an older one.
-		global $jetpack_packages_classmap;
-		if ( empty( $jetpack_packages_classmap ) ) {
-			return true;
-		}
-
-		// Version 2.4.0 added a new global and altered the reset semantics. We need to check
-		// the other global as well since it may also point at initialization.
-		// Note: We don't need to check for the class first because every autoloader that
-		// will set the latest version global requires this class in the classmap.
-		$replacing_version = $jetpack_packages_classmap[ AutoloadGenerator::class ]['version'];
-		if ( $this->version_selector->is_dev_version( $replacing_version ) || version_compare( $replacing_version, '2.4.0.0', '>=' ) ) {
-			global $jetpack_autoloader_loader;
-			if ( ! isset( $jetpack_autoloader_loader ) ) {
-				return true;
-			}
-		}
-
-		return false;
-	}
-
-	/**
-	 * Activates an autoloader using the given plugins and activates it.
-	 *
-	 * @param string[] $plugins The plugins to initialize the autoloader for.
-	 */
-	public function activate_autoloader( $plugins ) {
-		global $jetpack_packages_psr4;
-		$jetpack_packages_psr4 = array();
-		$this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_psr4.php', $jetpack_packages_psr4 );
-
-		global $jetpack_packages_classmap;
-		$jetpack_packages_classmap = array();
-		$this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_classmap.php', $jetpack_packages_classmap );
-
-		global $jetpack_packages_filemap;
-		$jetpack_packages_filemap = array();
-		$this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_filemap.php', $jetpack_packages_filemap );
-
-		$loader = new Version_Loader(
-			$this->version_selector,
-			$jetpack_packages_classmap,
-			$jetpack_packages_psr4,
-			$jetpack_packages_filemap
-		);
-
-		$this->php_autoloader->register_autoloader( $loader );
-
-		// Now that the autoloader is active we can load the filemap.
-		$loader->load_filemap();
-	}
-
-	/**
-	 * Resets the active autoloader and all related global state.
-	 */
-	public function reset_autoloader() {
-		$this->php_autoloader->unregister_autoloader();
-		$this->hook_manager->reset();
-
-		// Clear all of the autoloader globals so that older autoloaders don't do anything strange.
-		global $jetpack_autoloader_latest_version;
-		$jetpack_autoloader_latest_version = null;
-
-		global $jetpack_packages_classmap;
-		$jetpack_packages_classmap = array(); // Must be array to avoid exceptions in old autoloaders!
-
-		global $jetpack_packages_psr4;
-		$jetpack_packages_psr4 = array(); // Must be array to avoid exceptions in old autoloaders!
-
-		global $jetpack_packages_filemap;
-		$jetpack_packages_filemap = array(); // Must be array to avoid exceptions in old autoloaders!
-	}
+    /**
+     * The PHP_Autoloader instance.
+     *
+     * @var PHP_Autoloader
+     */
+    private $php_autoloader;
+
+    /**
+     * The Hook_Manager instance.
+     *
+     * @var Hook_Manager
+     */
+    private $hook_manager;
+
+    /**
+     * The Manifest_Reader instance.
+     *
+     * @var Manifest_Reader
+     */
+    private $manifest_reader;
+
+    /**
+     * The Version_Selector instance.
+     *
+     * @var Version_Selector
+     */
+    private $version_selector;
+
+    /**
+     * The constructor.
+     *
+     * @param PHP_Autoloader   $php_autoloader The PHP_Autoloader instance.
+     * @param Hook_Manager     $hook_manager The Hook_Manager instance.
+     * @param Manifest_Reader  $manifest_reader The Manifest_Reader instance.
+     * @param Version_Selector $version_selector The Version_Selector instance.
+     */
+    public function __construct( $php_autoloader, $hook_manager, $manifest_reader, $version_selector ) {
+        $this->php_autoloader   = $php_autoloader;
+        $this->hook_manager     = $hook_manager;
+        $this->manifest_reader  = $manifest_reader;
+        $this->version_selector = $version_selector;
+    }
+
+    /**
+     * Checks to see whether or not an autoloader is currently in the process of initializing.
+     *
+     * @return bool
+     */
+    public function is_initializing() {
+        // If no version has been set it means that no autoloader has started initializing yet.
+        global $jetpack_autoloader_latest_version;
+        if ( ! isset( $jetpack_autoloader_latest_version ) ) {
+            return false;
+        }
+
+        // When the version is set but the classmap is not it ALWAYS means that this is the
+        // latest autoloader and is being included by an older one.
+        global $jetpack_packages_classmap;
+        if ( empty( $jetpack_packages_classmap ) ) {
+            return true;
+        }
+
+        // Version 2.4.0 added a new global and altered the reset semantics. We need to check
+        // the other global as well since it may also point at initialization.
+        // Note: We don't need to check for the class first because every autoloader that
+        // will set the latest version global requires this class in the classmap.
+        $replacing_version = $jetpack_packages_classmap[ AutoloadGenerator::class ]['version'];
+        if ( $this->version_selector->is_dev_version( $replacing_version ) || version_compare( $replacing_version, '2.4.0.0', '>=' ) ) {
+            global $jetpack_autoloader_loader;
+            if ( ! isset( $jetpack_autoloader_loader ) ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Activates an autoloader using the given plugins and activates it.
+     *
+     * @param string[] $plugins The plugins to initialize the autoloader for.
+     */
+    public function activate_autoloader( $plugins ) {
+        global $jetpack_packages_psr4;
+        $jetpack_packages_psr4 = array();
+        $this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_psr4.php', $jetpack_packages_psr4 );
+
+        global $jetpack_packages_classmap;
+        $jetpack_packages_classmap = array();
+        $this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_classmap.php', $jetpack_packages_classmap );
+
+        global $jetpack_packages_filemap;
+        $jetpack_packages_filemap = array();
+        $this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_filemap.php', $jetpack_packages_filemap );
+
+        $loader = new Version_Loader(
+            $this->version_selector,
+            $jetpack_packages_classmap,
+            $jetpack_packages_psr4,
+            $jetpack_packages_filemap
+        );
+
+        $this->php_autoloader->register_autoloader( $loader );
+
+        // Now that the autoloader is active we can load the filemap.
+        $loader->load_filemap();
+    }
+
+    /**
+     * Resets the active autoloader and all related global state.
+     */
+    public function reset_autoloader() {
+        $this->php_autoloader->unregister_autoloader();
+        $this->hook_manager->reset();
+
+        // Clear all of the autoloader globals so that older autoloaders don't do anything strange.
+        global $jetpack_autoloader_latest_version;
+        $jetpack_autoloader_latest_version = null;
+
+        global $jetpack_packages_classmap;
+        $jetpack_packages_classmap = array(); // Must be array to avoid exceptions in old autoloaders!
+
+        global $jetpack_packages_psr4;
+        $jetpack_packages_psr4 = array(); // Must be array to avoid exceptions in old autoloaders!
+
+        global $jetpack_packages_filemap;
+        $jetpack_packages_filemap = array(); // Must be array to avoid exceptions in old autoloaders!
+    }
 }

Spacing +11 added lines, -11 removed lines

@@ -44,7 +44,7 @@ 
 	 * @param Manifest_Reader  $manifest_reader The Manifest_Reader instance.
 	 * @param Version_Selector $version_selector The Version_Selector instance.
 	 */
-	public function __construct( $php_autoloader, $hook_manager, $manifest_reader, $version_selector ) {
+	public function __construct($php_autoloader, $hook_manager, $manifest_reader, $version_selector) {
 		$this->php_autoloader   = $php_autoloader;
 		$this->hook_manager     = $hook_manager;
 		$this->manifest_reader  = $manifest_reader;
@@ -59,14 +59,14 @@ 
 	public function is_initializing() {
 		// If no version has been set it means that no autoloader has started initializing yet.
 		global $jetpack_autoloader_latest_version;
-		if ( ! isset( $jetpack_autoloader_latest_version ) ) {
+		if (!isset($jetpack_autoloader_latest_version)) {
 			return false;
 		}
 
 		// When the version is set but the classmap is not it ALWAYS means that this is the
 		// latest autoloader and is being included by an older one.
 		global $jetpack_packages_classmap;
-		if ( empty( $jetpack_packages_classmap ) ) {
+		if (empty($jetpack_packages_classmap)) {
 			return true;
 		}
 
@@ -74,10 +74,10 @@ 
 		// the other global as well since it may also point at initialization.
 		// Note: We don't need to check for the class first because every autoloader that
 		// will set the latest version global requires this class in the classmap.
-		$replacing_version = $jetpack_packages_classmap[ AutoloadGenerator::class ]['version'];
-		if ( $this->version_selector->is_dev_version( $replacing_version ) || version_compare( $replacing_version, '2.4.0.0', '>=' ) ) {
+		$replacing_version = $jetpack_packages_classmap[AutoloadGenerator::class]['version'];
+		if ($this->version_selector->is_dev_version($replacing_version) || version_compare($replacing_version, '2.4.0.0', '>=')) {
 			global $jetpack_autoloader_loader;
-			if ( ! isset( $jetpack_autoloader_loader ) ) {
+			if (!isset($jetpack_autoloader_loader)) {
 				return true;
 			}
 		}
@@ -90,18 +90,18 @@ 
 	 *
 	 * @param string[] $plugins The plugins to initialize the autoloader for.
 	 */
-	public function activate_autoloader( $plugins ) {
+	public function activate_autoloader($plugins) {
 		global $jetpack_packages_psr4;
 		$jetpack_packages_psr4 = array();
-		$this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_psr4.php', $jetpack_packages_psr4 );
+		$this->manifest_reader->read_manifests($plugins, 'vendor/composer/jetpack_autoload_psr4.php', $jetpack_packages_psr4);
 
 		global $jetpack_packages_classmap;
 		$jetpack_packages_classmap = array();
-		$this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_classmap.php', $jetpack_packages_classmap );
+		$this->manifest_reader->read_manifests($plugins, 'vendor/composer/jetpack_autoload_classmap.php', $jetpack_packages_classmap);
 
 		global $jetpack_packages_filemap;
 		$jetpack_packages_filemap = array();
-		$this->manifest_reader->read_manifests( $plugins, 'vendor/composer/jetpack_autoload_filemap.php', $jetpack_packages_filemap );
+		$this->manifest_reader->read_manifests($plugins, 'vendor/composer/jetpack_autoload_filemap.php', $jetpack_packages_filemap);
 
 		$loader = new Version_Loader(
 			$this->version_selector,
@@ -110,7 +110,7 @@ 
 			$jetpack_packages_filemap
 		);
 
-		$this->php_autoloader->register_autoloader( $loader );
+		$this->php_autoloader->register_autoloader($loader);
 
 		// Now that the autoloader is active we can load the filemap.
 		$loader->load_filemap();

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/class-manifest-reader.php

Indentation +73 added lines, -73 removed lines

@@ -6,86 +6,86 @@
  */
 class Manifest_Reader {
 
-	/**
-	 * The Version_Selector object.
-	 *
-	 * @var Version_Selector
-	 */
-	private $version_selector;
+    /**
+     * The Version_Selector object.
+     *
+     * @var Version_Selector
+     */
+    private $version_selector;
 
-	/**
-	 * The constructor.
-	 *
-	 * @param Version_Selector $version_selector The Version_Selector object.
-	 */
-	public function __construct( $version_selector ) {
-		$this->version_selector = $version_selector;
-	}
+    /**
+     * The constructor.
+     *
+     * @param Version_Selector $version_selector The Version_Selector object.
+     */
+    public function __construct( $version_selector ) {
+        $this->version_selector = $version_selector;
+    }
 
-	/**
-	 * Reads all of the manifests in the given plugin paths.
-	 *
-	 * @param array  $plugin_paths  The paths to the plugins we're loading the manifest in.
-	 * @param string $manifest_path The path that we're loading the manifest from in each plugin.
-	 * @param array  $path_map The path map to add the contents of the manifests to.
-	 *
-	 * @return array $path_map The path map we've built using the manifests in each plugin.
-	 */
-	public function read_manifests( $plugin_paths, $manifest_path, &$path_map ) {
-		$file_paths = array_map(
-			function ( $path ) use ( $manifest_path ) {
-				return trailingslashit( $path ) . $manifest_path;
-			},
-			$plugin_paths
-		);
+    /**
+     * Reads all of the manifests in the given plugin paths.
+     *
+     * @param array  $plugin_paths  The paths to the plugins we're loading the manifest in.
+     * @param string $manifest_path The path that we're loading the manifest from in each plugin.
+     * @param array  $path_map The path map to add the contents of the manifests to.
+     *
+     * @return array $path_map The path map we've built using the manifests in each plugin.
+     */
+    public function read_manifests( $plugin_paths, $manifest_path, &$path_map ) {
+        $file_paths = array_map(
+            function ( $path ) use ( $manifest_path ) {
+                return trailingslashit( $path ) . $manifest_path;
+            },
+            $plugin_paths
+        );
 
-		foreach ( $file_paths as $path ) {
-			$this->register_manifest( $path, $path_map );
-		}
+        foreach ( $file_paths as $path ) {
+            $this->register_manifest( $path, $path_map );
+        }
 
-		return $path_map;
-	}
+        return $path_map;
+    }
 
-	/**
-	 * Registers a plugin's manifest file with the path map.
-	 *
-	 * @param string $manifest_path The absolute path to the manifest that we're loading.
-	 * @param array  $path_map The path map to add the contents of the manifest to.
-	 */
-	protected function register_manifest( $manifest_path, &$path_map ) {
-		if ( ! is_readable( $manifest_path ) ) {
-			return;
-		}
+    /**
+     * Registers a plugin's manifest file with the path map.
+     *
+     * @param string $manifest_path The absolute path to the manifest that we're loading.
+     * @param array  $path_map The path map to add the contents of the manifest to.
+     */
+    protected function register_manifest( $manifest_path, &$path_map ) {
+        if ( ! is_readable( $manifest_path ) ) {
+            return;
+        }
 
-		$manifest = require $manifest_path;
-		if ( ! is_array( $manifest ) ) {
-			return;
-		}
+        $manifest = require $manifest_path;
+        if ( ! is_array( $manifest ) ) {
+            return;
+        }
 
-		foreach ( $manifest as $key => $data ) {
-			$this->register_record( $key, $data, $path_map );
-		}
-	}
+        foreach ( $manifest as $key => $data ) {
+            $this->register_record( $key, $data, $path_map );
+        }
+    }
 
-	/**
-	 * Registers an entry from the manifest in the path map.
-	 *
-	 * @param string $key The identifier for the entry we're registering.
-	 * @param array  $data The data for the entry we're registering.
-	 * @param array  $path_map The path map to add the contents of the manifest to.
-	 */
-	protected function register_record( $key, $data, &$path_map ) {
-		if ( isset( $path_map[ $key ]['version'] ) ) {
-			$selected_version = $path_map[ $key ]['version'];
-		} else {
-			$selected_version = null;
-		}
+    /**
+     * Registers an entry from the manifest in the path map.
+     *
+     * @param string $key The identifier for the entry we're registering.
+     * @param array  $data The data for the entry we're registering.
+     * @param array  $path_map The path map to add the contents of the manifest to.
+     */
+    protected function register_record( $key, $data, &$path_map ) {
+        if ( isset( $path_map[ $key ]['version'] ) ) {
+            $selected_version = $path_map[ $key ]['version'];
+        } else {
+            $selected_version = null;
+        }
 
-		if ( $this->version_selector->is_version_update_required( $selected_version, $data['version'] ) ) {
-			$path_map[ $key ] = array(
-				'version' => $data['version'],
-				'path'    => $data['path'],
-			);
-		}
-	}
+        if ( $this->version_selector->is_version_update_required( $selected_version, $data['version'] ) ) {
+            $path_map[ $key ] = array(
+                'version' => $data['version'],
+                'path'    => $data['path'],
+            );
+        }
+    }
 }

Spacing +16 added lines, -16 removed lines

@@ -18,7 +18,7 @@ 
 	 *
 	 * @param Version_Selector $version_selector The Version_Selector object.
 	 */
-	public function __construct( $version_selector ) {
+	public function __construct($version_selector) {
 		$this->version_selector = $version_selector;
 	}
 
@@ -31,16 +31,16 @@ 
 	 *
 	 * @return array $path_map The path map we've built using the manifests in each plugin.
 	 */
-	public function read_manifests( $plugin_paths, $manifest_path, &$path_map ) {
+	public function read_manifests($plugin_paths, $manifest_path, &$path_map) {
 		$file_paths = array_map(
-			function ( $path ) use ( $manifest_path ) {
-				return trailingslashit( $path ) . $manifest_path;
+			function($path) use ($manifest_path) {
+				return trailingslashit($path) . $manifest_path;
 			},
 			$plugin_paths
 		);
 
-		foreach ( $file_paths as $path ) {
-			$this->register_manifest( $path, $path_map );
+		foreach ($file_paths as $path) {
+			$this->register_manifest($path, $path_map);
 		}
 
 		return $path_map;
@@ -52,18 +52,18 @@ 
 	 * @param string $manifest_path The absolute path to the manifest that we're loading.
 	 * @param array  $path_map The path map to add the contents of the manifest to.
 	 */
-	protected function register_manifest( $manifest_path, &$path_map ) {
-		if ( ! is_readable( $manifest_path ) ) {
+	protected function register_manifest($manifest_path, &$path_map) {
+		if (!is_readable($manifest_path)) {
 			return;
 		}
 
 		$manifest = require $manifest_path;
-		if ( ! is_array( $manifest ) ) {
+		if (!is_array($manifest)) {
 			return;
 		}
 
-		foreach ( $manifest as $key => $data ) {
-			$this->register_record( $key, $data, $path_map );
+		foreach ($manifest as $key => $data) {
+			$this->register_record($key, $data, $path_map);
 		}
 	}
 
@@ -74,15 +74,15 @@ 
 	 * @param array  $data The data for the entry we're registering.
 	 * @param array  $path_map The path map to add the contents of the manifest to.
 	 */
-	protected function register_record( $key, $data, &$path_map ) {
-		if ( isset( $path_map[ $key ]['version'] ) ) {
-			$selected_version = $path_map[ $key ]['version'];
+	protected function register_record($key, $data, &$path_map) {
+		if (isset($path_map[$key]['version'])) {
+			$selected_version = $path_map[$key]['version'];
 		} else {
 			$selected_version = null;
 		}
 
-		if ( $this->version_selector->is_version_update_required( $selected_version, $data['version'] ) ) {
-			$path_map[ $key ] = array(
+		if ($this->version_selector->is_version_update_required($selected_version, $data['version'])) {
+			$path_map[$key] = array(
 				'version' => $data['version'],
 				'path'    => $data['path'],
 			);

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/class-autoloader.php

Indentation +73 added lines, -73 removed lines

@@ -6,77 +6,77 @@
  */
 class Autoloader {
 
-	/**
-	 * Checks to see whether or not the autoloader should be initialized and then initializes it if so.
-	 *
-	 * @param Container|null $container The container we want to use for autoloader initialization. If none is given
-	 *                                  then a container will be created automatically.
-	 */
-	public static function init( $container = null ) {
-		// The container holds and manages the lifecycle of our dependencies
-		// to make them easier to work with and increase flexibility.
-		if ( ! isset( $container ) ) {
-			require_once __DIR__ . '/class-container.php';
-			$container = new Container();
-		}
-
-		// phpcs:disable Generic.Commenting.DocComment.MissingShort
-
-		/** @var Autoloader_Handler $autoloader_handler */
-		$autoloader_handler = $container->get( Autoloader_Handler::class );
-
-		// If the autoloader is already initializing it means that it has included us as the latest.
-		$was_included_by_autoloader = $autoloader_handler->is_initializing();
-
-		/** @var Plugin_Locator $plugin_locator */
-		$plugin_locator = $container->get( Plugin_Locator::class );
-
-		/** @var Plugins_Handler $plugins_handler */
-		$plugins_handler = $container->get( Plugins_Handler::class );
-
-		// The current plugin is the one that we are attempting to initialize here.
-		$current_plugin = $plugin_locator->find_current_plugin();
-
-		// The active plugins are those that we were able to discover on the site. This list will not
-		// include mu-plugins, those activated by code, or those who are hidden by filtering. We also
-		// want to take care to not consider the current plugin unknown if it was included by an
-		// autoloader. This avoids the case where a plugin will be marked "active" while deactivated
-		// due to it having the latest autoloader.
-		$active_plugins = $plugins_handler->get_active_plugins( true, ! $was_included_by_autoloader );
-
-		// The cached plugins are all of those that were active or discovered by the autoloader during a previous request.
-		// Note that it's possible this list will include plugins that have since been deactivated, but after a request
-		// the cache should be updated and the deactivated plugins will be removed.
-		$cached_plugins = $plugins_handler->get_cached_plugins();
-
-		// We combine the active list and cached list to preemptively load classes for plugins that are
-		// presently unknown but will be loaded during the request. While this may result in us considering packages in
-		// deactivated plugins there shouldn't be any problems as a result and the eventual consistency is sufficient.
-		$all_plugins = array_merge( $active_plugins, $cached_plugins );
-
-		// In particular we also include the current plugin to address the case where it is the latest autoloader
-		// but also unknown (and not cached). We don't want it in the active list because we don't know that it
-		// is active but we need it in the all plugins list so that it is considered by the autoloader.
-		$all_plugins[] = $current_plugin;
-
-		// We require uniqueness in the array to avoid processing the same plugin more than once.
-		$all_plugins = array_values( array_unique( $all_plugins ) );
-
-		/** @var Latest_Autoloader_Guard $guard */
-		$guard = $container->get( Latest_Autoloader_Guard::class );
-		if ( $guard->should_stop_init( $current_plugin, $all_plugins, $was_included_by_autoloader ) ) {
-			return;
-		}
-
-		// Initialize the autoloader using the handler now that we're ready.
-		$autoloader_handler->activate_autoloader( $all_plugins );
-
-		/** @var Hook_Manager $hook_manager */
-		$hook_manager = $container->get( Hook_Manager::class );
-
-		// Register a shutdown handler to clean up the autoloader.
-		$hook_manager->add_action( 'shutdown', new Shutdown_Handler( $plugins_handler, $cached_plugins, $was_included_by_autoloader ) );
-
-		// phpcs:enable Generic.Commenting.DocComment.MissingShort
-	}
+    /**
+     * Checks to see whether or not the autoloader should be initialized and then initializes it if so.
+     *
+     * @param Container|null $container The container we want to use for autoloader initialization. If none is given
+     *                                  then a container will be created automatically.
+     */
+    public static function init( $container = null ) {
+        // The container holds and manages the lifecycle of our dependencies
+        // to make them easier to work with and increase flexibility.
+        if ( ! isset( $container ) ) {
+            require_once __DIR__ . '/class-container.php';
+            $container = new Container();
+        }
+
+        // phpcs:disable Generic.Commenting.DocComment.MissingShort
+
+        /** @var Autoloader_Handler $autoloader_handler */
+        $autoloader_handler = $container->get( Autoloader_Handler::class );
+
+        // If the autoloader is already initializing it means that it has included us as the latest.
+        $was_included_by_autoloader = $autoloader_handler->is_initializing();
+
+        /** @var Plugin_Locator $plugin_locator */
+        $plugin_locator = $container->get( Plugin_Locator::class );
+
+        /** @var Plugins_Handler $plugins_handler */
+        $plugins_handler = $container->get( Plugins_Handler::class );
+
+        // The current plugin is the one that we are attempting to initialize here.
+        $current_plugin = $plugin_locator->find_current_plugin();
+
+        // The active plugins are those that we were able to discover on the site. This list will not
+        // include mu-plugins, those activated by code, or those who are hidden by filtering. We also
+        // want to take care to not consider the current plugin unknown if it was included by an
+        // autoloader. This avoids the case where a plugin will be marked "active" while deactivated
+        // due to it having the latest autoloader.
+        $active_plugins = $plugins_handler->get_active_plugins( true, ! $was_included_by_autoloader );
+
+        // The cached plugins are all of those that were active or discovered by the autoloader during a previous request.
+        // Note that it's possible this list will include plugins that have since been deactivated, but after a request
+        // the cache should be updated and the deactivated plugins will be removed.
+        $cached_plugins = $plugins_handler->get_cached_plugins();
+
+        // We combine the active list and cached list to preemptively load classes for plugins that are
+        // presently unknown but will be loaded during the request. While this may result in us considering packages in
+        // deactivated plugins there shouldn't be any problems as a result and the eventual consistency is sufficient.
+        $all_plugins = array_merge( $active_plugins, $cached_plugins );
+
+        // In particular we also include the current plugin to address the case where it is the latest autoloader
+        // but also unknown (and not cached). We don't want it in the active list because we don't know that it
+        // is active but we need it in the all plugins list so that it is considered by the autoloader.
+        $all_plugins[] = $current_plugin;
+
+        // We require uniqueness in the array to avoid processing the same plugin more than once.
+        $all_plugins = array_values( array_unique( $all_plugins ) );
+
+        /** @var Latest_Autoloader_Guard $guard */
+        $guard = $container->get( Latest_Autoloader_Guard::class );
+        if ( $guard->should_stop_init( $current_plugin, $all_plugins, $was_included_by_autoloader ) ) {
+            return;
+        }
+
+        // Initialize the autoloader using the handler now that we're ready.
+        $autoloader_handler->activate_autoloader( $all_plugins );
+
+        /** @var Hook_Manager $hook_manager */
+        $hook_manager = $container->get( Hook_Manager::class );
+
+        // Register a shutdown handler to clean up the autoloader.
+        $hook_manager->add_action( 'shutdown', new Shutdown_Handler( $plugins_handler, $cached_plugins, $was_included_by_autoloader ) );
+
+        // phpcs:enable Generic.Commenting.DocComment.MissingShort
+    }
 }

Spacing +13 added lines, -13 removed lines

@@ -12,10 +12,10 @@ 
 	 * @param Container|null $container The container we want to use for autoloader initialization. If none is given
 	 *                                  then a container will be created automatically.
 	 */
-	public static function init( $container = null ) {
+	public static function init($container = null) {
 		// The container holds and manages the lifecycle of our dependencies
 		// to make them easier to work with and increase flexibility.
-		if ( ! isset( $container ) ) {
+		if (!isset($container)) {
 			require_once __DIR__ . '/class-container.php';
 			$container = new Container();
 		}
@@ -23,16 +23,16 @@ 
 		// phpcs:disable Generic.Commenting.DocComment.MissingShort
 
 		/** @var Autoloader_Handler $autoloader_handler */
-		$autoloader_handler = $container->get( Autoloader_Handler::class );
+		$autoloader_handler = $container->get(Autoloader_Handler::class);
 
 		// If the autoloader is already initializing it means that it has included us as the latest.
 		$was_included_by_autoloader = $autoloader_handler->is_initializing();
 
 		/** @var Plugin_Locator $plugin_locator */
-		$plugin_locator = $container->get( Plugin_Locator::class );
+		$plugin_locator = $container->get(Plugin_Locator::class);
 
 		/** @var Plugins_Handler $plugins_handler */
-		$plugins_handler = $container->get( Plugins_Handler::class );
+		$plugins_handler = $container->get(Plugins_Handler::class);
 
 		// The current plugin is the one that we are attempting to initialize here.
 		$current_plugin = $plugin_locator->find_current_plugin();
@@ -42,7 +42,7 @@ 
 		// want to take care to not consider the current plugin unknown if it was included by an
 		// autoloader. This avoids the case where a plugin will be marked "active" while deactivated
 		// due to it having the latest autoloader.
-		$active_plugins = $plugins_handler->get_active_plugins( true, ! $was_included_by_autoloader );
+		$active_plugins = $plugins_handler->get_active_plugins(true, !$was_included_by_autoloader);
 
 		// The cached plugins are all of those that were active or discovered by the autoloader during a previous request.
 		// Note that it's possible this list will include plugins that have since been deactivated, but after a request
@@ -52,7 +52,7 @@ 
 		// We combine the active list and cached list to preemptively load classes for plugins that are
 		// presently unknown but will be loaded during the request. While this may result in us considering packages in
 		// deactivated plugins there shouldn't be any problems as a result and the eventual consistency is sufficient.
-		$all_plugins = array_merge( $active_plugins, $cached_plugins );
+		$all_plugins = array_merge($active_plugins, $cached_plugins);
 
 		// In particular we also include the current plugin to address the case where it is the latest autoloader
 		// but also unknown (and not cached). We don't want it in the active list because we don't know that it
@@ -60,22 +60,22 @@ 
 		$all_plugins[] = $current_plugin;
 
 		// We require uniqueness in the array to avoid processing the same plugin more than once.
-		$all_plugins = array_values( array_unique( $all_plugins ) );
+		$all_plugins = array_values(array_unique($all_plugins));
 
 		/** @var Latest_Autoloader_Guard $guard */
-		$guard = $container->get( Latest_Autoloader_Guard::class );
-		if ( $guard->should_stop_init( $current_plugin, $all_plugins, $was_included_by_autoloader ) ) {
+		$guard = $container->get(Latest_Autoloader_Guard::class);
+		if ($guard->should_stop_init($current_plugin, $all_plugins, $was_included_by_autoloader)) {
 			return;
 		}
 
 		// Initialize the autoloader using the handler now that we're ready.
-		$autoloader_handler->activate_autoloader( $all_plugins );
+		$autoloader_handler->activate_autoloader($all_plugins);
 
 		/** @var Hook_Manager $hook_manager */
-		$hook_manager = $container->get( Hook_Manager::class );
+		$hook_manager = $container->get(Hook_Manager::class);
 
 		// Register a shutdown handler to clean up the autoloader.
-		$hook_manager->add_action( 'shutdown', new Shutdown_Handler( $plugins_handler, $cached_plugins, $was_included_by_autoloader ) );
+		$hook_manager->add_action('shutdown', new Shutdown_Handler($plugins_handler, $cached_plugins, $was_included_by_autoloader));
 
 		// phpcs:enable Generic.Commenting.DocComment.MissingShort
 	}

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/AutoloadFileWriter.php

Indentation +65 added lines, -65 removed lines

@@ -23,10 +23,10 @@ 
  */
 class AutoloadFileWriter {
 
-	/**
-	 * The file comment to use.
-	 */
-	const COMMENT = <<<AUTOLOADER_COMMENT
+    /**
+     * The file comment to use.
+     */
+    const COMMENT = <<<AUTOLOADER_COMMENT
 /**
  * This file was automatically generated by automattic/jetpack-autoloader.
  *
@@ -35,71 +35,71 @@ 
 
 AUTOLOADER_COMMENT;
 
-	/**
-	 * Copies autoloader files and replaces any placeholders in them.
-	 *
-	 * @param IOInterface|null $io An IO for writing to.
-	 * @param string           $outDir The directory to place the autoloader files in.
-	 * @param string           $suffix The suffix to use in the autoloader's namespace.
-	 */
-	public static function copyAutoloaderFiles( $io, $outDir, $suffix ) {
-		$renameList = array(
-			'autoload.php' => '../autoload_packages.php',
-		);
-		$ignoreList = array(
-			'AutoloadGenerator.php',
-			'AutoloadProcessor.php',
-			'CustomAutoloaderPlugin.php',
-			'ManifestGenerator.php',
-			'AutoloadFileWriter.php',
-		);
+    /**
+     * Copies autoloader files and replaces any placeholders in them.
+     *
+     * @param IOInterface|null $io An IO for writing to.
+     * @param string           $outDir The directory to place the autoloader files in.
+     * @param string           $suffix The suffix to use in the autoloader's namespace.
+     */
+    public static function copyAutoloaderFiles( $io, $outDir, $suffix ) {
+        $renameList = array(
+            'autoload.php' => '../autoload_packages.php',
+        );
+        $ignoreList = array(
+            'AutoloadGenerator.php',
+            'AutoloadProcessor.php',
+            'CustomAutoloaderPlugin.php',
+            'ManifestGenerator.php',
+            'AutoloadFileWriter.php',
+        );
 
-		// Copy all of the autoloader files.
-		$files = scandir( __DIR__ );
-		foreach ( $files as $file ) {
-			// Only PHP files will be copied.
-			if ( substr( $file, -4 ) !== '.php' ) {
-				continue;
-			}
+        // Copy all of the autoloader files.
+        $files = scandir( __DIR__ );
+        foreach ( $files as $file ) {
+            // Only PHP files will be copied.
+            if ( substr( $file, -4 ) !== '.php' ) {
+                continue;
+            }
 
-			if ( in_array( $file, $ignoreList, true ) ) {
-				continue;
-			}
+            if ( in_array( $file, $ignoreList, true ) ) {
+                continue;
+            }
 
-			$newFile = isset( $renameList[ $file ] ) ? $renameList[ $file ] : $file;
-			$content = self::prepareAutoloaderFile( $file, $suffix );
+            $newFile = isset( $renameList[ $file ] ) ? $renameList[ $file ] : $file;
+            $content = self::prepareAutoloaderFile( $file, $suffix );
 
-			$written = file_put_contents( $outDir . '/' . $newFile, $content );
-			if ( $io ) {
-				if ( $written ) {
-					$io->writeError( "  <info>Generated: $newFile</info>" );
-				} else {
-					$io->writeError( "  <error>Error: $newFile</error>" );
-				}
-			}
-		}
-	}
+            $written = file_put_contents( $outDir . '/' . $newFile, $content );
+            if ( $io ) {
+                if ( $written ) {
+                    $io->writeError( "  <info>Generated: $newFile</info>" );
+                } else {
+                    $io->writeError( "  <error>Error: $newFile</error>" );
+                }
+            }
+        }
+    }
 
-	/**
-	 * Prepares an autoloader file to be written to the destination.
-	 *
-	 * @param String $filename a file to prepare.
-	 * @param String $suffix   Unique suffix used in the namespace.
-	 *
-	 * @return string
-	 */
-	private static function prepareAutoloaderFile( $filename, $suffix ) {
-		$header  = self::COMMENT;
-		$header .= PHP_EOL;
-		$header .= 'namespace Automattic\Jetpack\Autoloader\jp' . $suffix . ';';
-		$header .= PHP_EOL . PHP_EOL;
+    /**
+     * Prepares an autoloader file to be written to the destination.
+     *
+     * @param String $filename a file to prepare.
+     * @param String $suffix   Unique suffix used in the namespace.
+     *
+     * @return string
+     */
+    private static function prepareAutoloaderFile( $filename, $suffix ) {
+        $header  = self::COMMENT;
+        $header .= PHP_EOL;
+        $header .= 'namespace Automattic\Jetpack\Autoloader\jp' . $suffix . ';';
+        $header .= PHP_EOL . PHP_EOL;
 
-		$sourceLoader  = fopen( __DIR__ . '/' . $filename, 'r' );
-		$file_contents = stream_get_contents( $sourceLoader );
-		return str_replace(
-			'/* HEADER */',
-			$header,
-			$file_contents
-		);
-	}
+        $sourceLoader  = fopen( __DIR__ . '/' . $filename, 'r' );
+        $file_contents = stream_get_contents( $sourceLoader );
+        return str_replace(
+            '/* HEADER */',
+            $header,
+            $file_contents
+        );
+    }
 }

Spacing +15 added lines, -15 removed lines

@@ -42,7 +42,7 @@ 
 	 * @param string           $outDir The directory to place the autoloader files in.
 	 * @param string           $suffix The suffix to use in the autoloader's namespace.
 	 */
-	public static function copyAutoloaderFiles( $io, $outDir, $suffix ) {
+	public static function copyAutoloaderFiles($io, $outDir, $suffix) {
 		$renameList = array(
 			'autoload.php' => '../autoload_packages.php',
 		);
@@ -55,26 +55,26 @@ 
 		);
 
 		// Copy all of the autoloader files.
-		$files = scandir( __DIR__ );
-		foreach ( $files as $file ) {
+		$files = scandir(__DIR__);
+		foreach ($files as $file) {
 			// Only PHP files will be copied.
-			if ( substr( $file, -4 ) !== '.php' ) {
+			if (substr($file, -4) !== '.php') {
 				continue;
 			}
 
-			if ( in_array( $file, $ignoreList, true ) ) {
+			if (in_array($file, $ignoreList, true)) {
 				continue;
 			}
 
-			$newFile = isset( $renameList[ $file ] ) ? $renameList[ $file ] : $file;
-			$content = self::prepareAutoloaderFile( $file, $suffix );
+			$newFile = isset($renameList[$file]) ? $renameList[$file] : $file;
+			$content = self::prepareAutoloaderFile($file, $suffix);
 
-			$written = file_put_contents( $outDir . '/' . $newFile, $content );
-			if ( $io ) {
-				if ( $written ) {
-					$io->writeError( "  <info>Generated: $newFile</info>" );
+			$written = file_put_contents($outDir . '/' . $newFile, $content);
+			if ($io) {
+				if ($written) {
+					$io->writeError("  <info>Generated: $newFile</info>");
 				} else {
-					$io->writeError( "  <error>Error: $newFile</error>" );
+					$io->writeError("  <error>Error: $newFile</error>");
 				}
 			}
 		}
@@ -88,14 +88,14 @@ 
 	 *
 	 * @return string
 	 */
-	private static function prepareAutoloaderFile( $filename, $suffix ) {
+	private static function prepareAutoloaderFile($filename, $suffix) {
 		$header  = self::COMMENT;
 		$header .= PHP_EOL;
 		$header .= 'namespace Automattic\Jetpack\Autoloader\jp' . $suffix . ';';
 		$header .= PHP_EOL . PHP_EOL;
 
-		$sourceLoader  = fopen( __DIR__ . '/' . $filename, 'r' );
-		$file_contents = stream_get_contents( $sourceLoader );
+		$sourceLoader  = fopen(__DIR__ . '/' . $filename, 'r');
+		$file_contents = stream_get_contents($sourceLoader);
 		return str_replace(
 			'/* HEADER */',
 			$header,

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/class-plugins-handler.php

Indentation +148 added lines, -148 removed lines

@@ -5,152 +5,152 @@
  * This class handles locating and caching all of the active plugins.
  */
 class Plugins_Handler {
-	/**
-	 * The transient key for plugin paths.
-	 */
-	const TRANSIENT_KEY = 'jetpack_autoloader_plugin_paths';
-
-	/**
-	 * The locator for finding plugins in different locations.
-	 *
-	 * @var Plugin_Locator
-	 */
-	private $plugin_locator;
-
-	/**
-	 * The processor for transforming cached paths.
-	 *
-	 * @var Path_Processor
-	 */
-	private $path_processor;
-
-	/**
-	 * The constructor.
-	 *
-	 * @param Plugin_Locator $plugin_locator The locator for finding active plugins.
-	 * @param Path_Processor $path_processor The processor for transforming cached paths.
-	 */
-	public function __construct( $plugin_locator, $path_processor ) {
-		$this->plugin_locator = $plugin_locator;
-		$this->path_processor = $path_processor;
-	}
-
-	/**
-	 * Gets all of the active plugins we can find.
-	 *
-	 * @param bool $include_deactivating When true, plugins deactivating this request will be considered active.
-	 * @param bool $record_unknown When true, the current plugin will be marked as active and recorded when unknown.
-	 *
-	 * @return string[]
-	 */
-	public function get_active_plugins( $include_deactivating, $record_unknown ) {
-		global $jetpack_autoloader_activating_plugins_paths;
-
-		// We're going to build a unique list of plugins from a few different sources
-		// to find all of our "active" plugins. While we need to return an integer
-		// array, we're going to use an associative array internally to reduce
-		// the amount of time that we're going to spend checking uniqueness
-		// and merging different arrays together to form the output.
-		$active_plugins = array();
-
-		// Make sure that plugins which have activated this request are considered as "active" even though
-		// they probably won't be present in any option.
-		if ( is_array( $jetpack_autoloader_activating_plugins_paths ) ) {
-			foreach ( $jetpack_autoloader_activating_plugins_paths as $path ) {
-				$active_plugins[ $path ] = $path;
-			}
-		}
-
-		// This option contains all of the plugins that have been activated.
-		$plugins = $this->plugin_locator->find_using_option( 'active_plugins' );
-		foreach ( $plugins as $path ) {
-			$active_plugins[ $path ] = $path;
-		}
-
-		// This option contains all of the multisite plugins that have been activated.
-		if ( is_multisite() ) {
-			$plugins = $this->plugin_locator->find_using_option( 'active_sitewide_plugins', true );
-			foreach ( $plugins as $path ) {
-				$active_plugins[ $path ] = $path;
-			}
-		}
-
-		// These actions contain plugins that are being activated/deactivated during this request.
-		$plugins = $this->plugin_locator->find_using_request_action( array( 'activate', 'activate-selected', 'deactivate', 'deactivate-selected' ) );
-		foreach ( $plugins as $path ) {
-			$active_plugins[ $path ] = $path;
-		}
-
-		// When the current plugin isn't considered "active" there's a problem.
-		// Since we're here, the plugin is active and currently being loaded.
-		// We can support this case (mu-plugins and non-standard activation)
-		// by adding the current plugin to the active list and marking it
-		// as an unknown (activating) plugin. This also has the benefit
-		// of causing a reset because the active plugins list has
-		// been changed since it was saved in the global.
-		$current_plugin = $this->plugin_locator->find_current_plugin();
-		if ( $record_unknown && ! in_array( $current_plugin, $active_plugins, true ) ) {
-			$active_plugins[ $current_plugin ]             = $current_plugin;
-			$jetpack_autoloader_activating_plugins_paths[] = $current_plugin;
-		}
-
-		// When deactivating plugins aren't desired we should entirely remove them from the active list.
-		if ( ! $include_deactivating ) {
-			// These actions contain plugins that are being deactivated during this request.
-			$plugins = $this->plugin_locator->find_using_request_action( array( 'deactivate', 'deactivate-selected' ) );
-			foreach ( $plugins as $path ) {
-				unset( $active_plugins[ $path ] );
-			}
-		}
-
-		// Transform the array so that we don't have to worry about the keys interacting with other array types later.
-		return array_values( $active_plugins );
-	}
-
-	/**
-	 * Gets all of the cached plugins if there are any.
-	 *
-	 * @return string[]
-	 */
-	public function get_cached_plugins() {
-		$cached = get_transient( self::TRANSIENT_KEY );
-		if ( ! is_array( $cached ) || empty( $cached ) ) {
-			return array();
-		}
-
-		// We need to expand the tokens to an absolute path for this webserver.
-		return array_map( array( $this->path_processor, 'untokenize_path_constants' ), $cached );
-	}
-
-	/**
-	 * Saves the plugin list to the cache.
-	 *
-	 * @param array $plugins The plugin list to save to the cache.
-	 */
-	public function cache_plugins( $plugins ) {
-		// We store the paths in a tokenized form so that that webservers with different absolute paths don't break.
-		$plugins = array_map( array( $this->path_processor, 'tokenize_path_constants' ), $plugins );
-
-		set_transient( self::TRANSIENT_KEY, $plugins );
-	}
-
-	/**
-	 * Checks to see whether or not the plugin list given has changed when compared to the
-	 * shared `$jetpack_autoloader_cached_plugin_paths` global. This allows us to deal
-	 * with cases where the active list may change due to filtering..
-	 *
-	 * @param string[] $plugins The plugins list to check against the global cache.
-	 *
-	 * @return bool True if the plugins have changed, otherwise false.
-	 */
-	public function have_plugins_changed( $plugins ) {
-		global $jetpack_autoloader_cached_plugin_paths;
-
-		if ( $jetpack_autoloader_cached_plugin_paths !== $plugins ) {
-			$jetpack_autoloader_cached_plugin_paths = $plugins;
-			return true;
-		}
-
-		return false;
-	}
+    /**
+     * The transient key for plugin paths.
+     */
+    const TRANSIENT_KEY = 'jetpack_autoloader_plugin_paths';
+
+    /**
+     * The locator for finding plugins in different locations.
+     *
+     * @var Plugin_Locator
+     */
+    private $plugin_locator;
+
+    /**
+     * The processor for transforming cached paths.
+     *
+     * @var Path_Processor
+     */
+    private $path_processor;
+
+    /**
+     * The constructor.
+     *
+     * @param Plugin_Locator $plugin_locator The locator for finding active plugins.
+     * @param Path_Processor $path_processor The processor for transforming cached paths.
+     */
+    public function __construct( $plugin_locator, $path_processor ) {
+        $this->plugin_locator = $plugin_locator;
+        $this->path_processor = $path_processor;
+    }
+
+    /**
+     * Gets all of the active plugins we can find.
+     *
+     * @param bool $include_deactivating When true, plugins deactivating this request will be considered active.
+     * @param bool $record_unknown When true, the current plugin will be marked as active and recorded when unknown.
+     *
+     * @return string[]
+     */
+    public function get_active_plugins( $include_deactivating, $record_unknown ) {
+        global $jetpack_autoloader_activating_plugins_paths;
+
+        // We're going to build a unique list of plugins from a few different sources
+        // to find all of our "active" plugins. While we need to return an integer
+        // array, we're going to use an associative array internally to reduce
+        // the amount of time that we're going to spend checking uniqueness
+        // and merging different arrays together to form the output.
+        $active_plugins = array();
+
+        // Make sure that plugins which have activated this request are considered as "active" even though
+        // they probably won't be present in any option.
+        if ( is_array( $jetpack_autoloader_activating_plugins_paths ) ) {
+            foreach ( $jetpack_autoloader_activating_plugins_paths as $path ) {
+                $active_plugins[ $path ] = $path;
+            }
+        }
+
+        // This option contains all of the plugins that have been activated.
+        $plugins = $this->plugin_locator->find_using_option( 'active_plugins' );
+        foreach ( $plugins as $path ) {
+            $active_plugins[ $path ] = $path;
+        }
+
+        // This option contains all of the multisite plugins that have been activated.
+        if ( is_multisite() ) {
+            $plugins = $this->plugin_locator->find_using_option( 'active_sitewide_plugins', true );
+            foreach ( $plugins as $path ) {
+                $active_plugins[ $path ] = $path;
+            }
+        }
+
+        // These actions contain plugins that are being activated/deactivated during this request.
+        $plugins = $this->plugin_locator->find_using_request_action( array( 'activate', 'activate-selected', 'deactivate', 'deactivate-selected' ) );
+        foreach ( $plugins as $path ) {
+            $active_plugins[ $path ] = $path;
+        }
+
+        // When the current plugin isn't considered "active" there's a problem.
+        // Since we're here, the plugin is active and currently being loaded.
+        // We can support this case (mu-plugins and non-standard activation)
+        // by adding the current plugin to the active list and marking it
+        // as an unknown (activating) plugin. This also has the benefit
+        // of causing a reset because the active plugins list has
+        // been changed since it was saved in the global.
+        $current_plugin = $this->plugin_locator->find_current_plugin();
+        if ( $record_unknown && ! in_array( $current_plugin, $active_plugins, true ) ) {
+            $active_plugins[ $current_plugin ]             = $current_plugin;
+            $jetpack_autoloader_activating_plugins_paths[] = $current_plugin;
+        }
+
+        // When deactivating plugins aren't desired we should entirely remove them from the active list.
+        if ( ! $include_deactivating ) {
+            // These actions contain plugins that are being deactivated during this request.
+            $plugins = $this->plugin_locator->find_using_request_action( array( 'deactivate', 'deactivate-selected' ) );
+            foreach ( $plugins as $path ) {
+                unset( $active_plugins[ $path ] );
+            }
+        }
+
+        // Transform the array so that we don't have to worry about the keys interacting with other array types later.
+        return array_values( $active_plugins );
+    }
+
+    /**
+     * Gets all of the cached plugins if there are any.
+     *
+     * @return string[]
+     */
+    public function get_cached_plugins() {
+        $cached = get_transient( self::TRANSIENT_KEY );
+        if ( ! is_array( $cached ) || empty( $cached ) ) {
+            return array();
+        }
+
+        // We need to expand the tokens to an absolute path for this webserver.
+        return array_map( array( $this->path_processor, 'untokenize_path_constants' ), $cached );
+    }
+
+    /**
+     * Saves the plugin list to the cache.
+     *
+     * @param array $plugins The plugin list to save to the cache.
+     */
+    public function cache_plugins( $plugins ) {
+        // We store the paths in a tokenized form so that that webservers with different absolute paths don't break.
+        $plugins = array_map( array( $this->path_processor, 'tokenize_path_constants' ), $plugins );
+
+        set_transient( self::TRANSIENT_KEY, $plugins );
+    }
+
+    /**
+     * Checks to see whether or not the plugin list given has changed when compared to the
+     * shared `$jetpack_autoloader_cached_plugin_paths` global. This allows us to deal
+     * with cases where the active list may change due to filtering..
+     *
+     * @param string[] $plugins The plugins list to check against the global cache.
+     *
+     * @return bool True if the plugins have changed, otherwise false.
+     */
+    public function have_plugins_changed( $plugins ) {
+        global $jetpack_autoloader_cached_plugin_paths;
+
+        if ( $jetpack_autoloader_cached_plugin_paths !== $plugins ) {
+            $jetpack_autoloader_cached_plugin_paths = $plugins;
+            return true;
+        }
+
+        return false;
+    }
 }

Spacing +30 added lines, -30 removed lines

@@ -30,7 +30,7 @@ 
 	 * @param Plugin_Locator $plugin_locator The locator for finding active plugins.
 	 * @param Path_Processor $path_processor The processor for transforming cached paths.
 	 */
-	public function __construct( $plugin_locator, $path_processor ) {
+	public function __construct($plugin_locator, $path_processor) {
 		$this->plugin_locator = $plugin_locator;
 		$this->path_processor = $path_processor;
 	}
@@ -43,7 +43,7 @@ 
 	 *
 	 * @return string[]
 	 */
-	public function get_active_plugins( $include_deactivating, $record_unknown ) {
+	public function get_active_plugins($include_deactivating, $record_unknown) {
 		global $jetpack_autoloader_activating_plugins_paths;
 
 		// We're going to build a unique list of plugins from a few different sources
@@ -55,30 +55,30 @@ 
 
 		// Make sure that plugins which have activated this request are considered as "active" even though
 		// they probably won't be present in any option.
-		if ( is_array( $jetpack_autoloader_activating_plugins_paths ) ) {
-			foreach ( $jetpack_autoloader_activating_plugins_paths as $path ) {
-				$active_plugins[ $path ] = $path;
+		if (is_array($jetpack_autoloader_activating_plugins_paths)) {
+			foreach ($jetpack_autoloader_activating_plugins_paths as $path) {
+				$active_plugins[$path] = $path;
 			}
 		}
 
 		// This option contains all of the plugins that have been activated.
-		$plugins = $this->plugin_locator->find_using_option( 'active_plugins' );
-		foreach ( $plugins as $path ) {
-			$active_plugins[ $path ] = $path;
+		$plugins = $this->plugin_locator->find_using_option('active_plugins');
+		foreach ($plugins as $path) {
+			$active_plugins[$path] = $path;
 		}
 
 		// This option contains all of the multisite plugins that have been activated.
-		if ( is_multisite() ) {
-			$plugins = $this->plugin_locator->find_using_option( 'active_sitewide_plugins', true );
-			foreach ( $plugins as $path ) {
-				$active_plugins[ $path ] = $path;
+		if (is_multisite()) {
+			$plugins = $this->plugin_locator->find_using_option('active_sitewide_plugins', true);
+			foreach ($plugins as $path) {
+				$active_plugins[$path] = $path;
 			}
 		}
 
 		// These actions contain plugins that are being activated/deactivated during this request.
-		$plugins = $this->plugin_locator->find_using_request_action( array( 'activate', 'activate-selected', 'deactivate', 'deactivate-selected' ) );
-		foreach ( $plugins as $path ) {
-			$active_plugins[ $path ] = $path;
+		$plugins = $this->plugin_locator->find_using_request_action(array('activate', 'activate-selected', 'deactivate', 'deactivate-selected'));
+		foreach ($plugins as $path) {
+			$active_plugins[$path] = $path;
 		}
 
 		// When the current plugin isn't considered "active" there's a problem.
@@ -89,22 +89,22 @@ 
 		// of causing a reset because the active plugins list has
 		// been changed since it was saved in the global.
 		$current_plugin = $this->plugin_locator->find_current_plugin();
-		if ( $record_unknown && ! in_array( $current_plugin, $active_plugins, true ) ) {
-			$active_plugins[ $current_plugin ]             = $current_plugin;
+		if ($record_unknown && !in_array($current_plugin, $active_plugins, true)) {
+			$active_plugins[$current_plugin]             = $current_plugin;
 			$jetpack_autoloader_activating_plugins_paths[] = $current_plugin;
 		}
 
 		// When deactivating plugins aren't desired we should entirely remove them from the active list.
-		if ( ! $include_deactivating ) {
+		if (!$include_deactivating) {
 			// These actions contain plugins that are being deactivated during this request.
-			$plugins = $this->plugin_locator->find_using_request_action( array( 'deactivate', 'deactivate-selected' ) );
-			foreach ( $plugins as $path ) {
-				unset( $active_plugins[ $path ] );
+			$plugins = $this->plugin_locator->find_using_request_action(array('deactivate', 'deactivate-selected'));
+			foreach ($plugins as $path) {
+				unset($active_plugins[$path]);
 			}
 		}
 
 		// Transform the array so that we don't have to worry about the keys interacting with other array types later.
-		return array_values( $active_plugins );
+		return array_values($active_plugins);
 	}
 
 	/**
@@ -113,13 +113,13 @@ 
 	 * @return string[]
 	 */
 	public function get_cached_plugins() {
-		$cached = get_transient( self::TRANSIENT_KEY );
-		if ( ! is_array( $cached ) || empty( $cached ) ) {
+		$cached = get_transient(self::TRANSIENT_KEY);
+		if (!is_array($cached) || empty($cached)) {
 			return array();
 		}
 
 		// We need to expand the tokens to an absolute path for this webserver.
-		return array_map( array( $this->path_processor, 'untokenize_path_constants' ), $cached );
+		return array_map(array($this->path_processor, 'untokenize_path_constants'), $cached);
 	}
 
 	/**
@@ -127,11 +127,11 @@ 
 	 *
 	 * @param array $plugins The plugin list to save to the cache.
 	 */
-	public function cache_plugins( $plugins ) {
+	public function cache_plugins($plugins) {
 		// We store the paths in a tokenized form so that that webservers with different absolute paths don't break.
-		$plugins = array_map( array( $this->path_processor, 'tokenize_path_constants' ), $plugins );
+		$plugins = array_map(array($this->path_processor, 'tokenize_path_constants'), $plugins);
 
-		set_transient( self::TRANSIENT_KEY, $plugins );
+		set_transient(self::TRANSIENT_KEY, $plugins);
 	}
 
 	/**
@@ -143,10 +143,10 @@ 
 	 *
 	 * @return bool True if the plugins have changed, otherwise false.
 	 */
-	public function have_plugins_changed( $plugins ) {
+	public function have_plugins_changed($plugins) {
 		global $jetpack_autoloader_cached_plugin_paths;
 
-		if ( $jetpack_autoloader_cached_plugin_paths !== $plugins ) {
+		if ($jetpack_autoloader_cached_plugin_paths !== $plugins) {
 			$jetpack_autoloader_cached_plugin_paths = $plugins;
 			return true;
 		}

plugins/woocommerce/packages/woocommerce-blocks/vendor/automattic/jetpack-autoloader/src/AutoloadProcessor.php

Indentation +155 added lines, -155 removed lines

@@ -19,162 +19,162 @@
  */
 class AutoloadProcessor {
 
-	/**
-	 * A callable for scanning a directory for all of its classes.
-	 *
-	 * @var callable
-	 */
-	private $classmapScanner;
-
-	/**
-	 * A callable for transforming a path into one to be used in code.
-	 *
-	 * @var callable
-	 */
-	private $pathCodeTransformer;
-
-	/**
-	 * The constructor.
-	 *
-	 * @param callable $classmapScanner A callable for scanning a directory for all of its classes.
-	 * @param callable $pathCodeTransformer A callable for transforming a path into one to be used in code.
-	 */
-	public function __construct( $classmapScanner, $pathCodeTransformer ) {
-		$this->classmapScanner     = $classmapScanner;
-		$this->pathCodeTransformer = $pathCodeTransformer;
-	}
-
-	/**
-	 * Processes the classmap autoloads into a relative path format including the version for each file.
-	 *
-	 * @param array $autoloads The autoloads we are processing.
-	 * @param bool  $scanPsrPackages Whether or not PSR packages should be converted to a classmap.
-	 *
-	 * @return array $processed
-	 */
-	public function processClassmap( $autoloads, $scanPsrPackages ) {
-		// We can't scan PSR packages if we don't actually have any.
-		if ( empty( $autoloads['psr-4'] ) ) {
-			$scanPsrPackages = false;
-		}
-
-		if ( empty( $autoloads['classmap'] ) && ! $scanPsrPackages ) {
-			return null;
-		}
-
-		$excludedClasses = null;
-		if ( ! empty( $autoloads['exclude-from-classmap'] ) ) {
-			$excludedClasses = '{(' . implode( '|', $autoloads['exclude-from-classmap'] ) . ')}';
-		}
-
-		$processed = array();
-
-		if ( $scanPsrPackages ) {
-			foreach ( $autoloads['psr-4'] as $namespace => $sources ) {
-				$namespace = empty( $namespace ) ? null : $namespace;
-
-				foreach ( $sources as $source ) {
-					$classmap = call_user_func( $this->classmapScanner, $source['path'], $excludedClasses, $namespace );
-
-					foreach ( $classmap as $class => $path ) {
-						$processed[ $class ] = array(
-							'version' => $source['version'],
-							'path'    => call_user_func( $this->pathCodeTransformer, $path ),
-						);
-					}
-				}
-			}
-		}
-
-		/*
+    /**
+     * A callable for scanning a directory for all of its classes.
+     *
+     * @var callable
+     */
+    private $classmapScanner;
+
+    /**
+     * A callable for transforming a path into one to be used in code.
+     *
+     * @var callable
+     */
+    private $pathCodeTransformer;
+
+    /**
+     * The constructor.
+     *
+     * @param callable $classmapScanner A callable for scanning a directory for all of its classes.
+     * @param callable $pathCodeTransformer A callable for transforming a path into one to be used in code.
+     */
+    public function __construct( $classmapScanner, $pathCodeTransformer ) {
+        $this->classmapScanner     = $classmapScanner;
+        $this->pathCodeTransformer = $pathCodeTransformer;
+    }
+
+    /**
+     * Processes the classmap autoloads into a relative path format including the version for each file.
+     *
+     * @param array $autoloads The autoloads we are processing.
+     * @param bool  $scanPsrPackages Whether or not PSR packages should be converted to a classmap.
+     *
+     * @return array $processed
+     */
+    public function processClassmap( $autoloads, $scanPsrPackages ) {
+        // We can't scan PSR packages if we don't actually have any.
+        if ( empty( $autoloads['psr-4'] ) ) {
+            $scanPsrPackages = false;
+        }
+
+        if ( empty( $autoloads['classmap'] ) && ! $scanPsrPackages ) {
+            return null;
+        }
+
+        $excludedClasses = null;
+        if ( ! empty( $autoloads['exclude-from-classmap'] ) ) {
+            $excludedClasses = '{(' . implode( '|', $autoloads['exclude-from-classmap'] ) . ')}';
+        }
+
+        $processed = array();
+
+        if ( $scanPsrPackages ) {
+            foreach ( $autoloads['psr-4'] as $namespace => $sources ) {
+                $namespace = empty( $namespace ) ? null : $namespace;
+
+                foreach ( $sources as $source ) {
+                    $classmap = call_user_func( $this->classmapScanner, $source['path'], $excludedClasses, $namespace );
+
+                    foreach ( $classmap as $class => $path ) {
+                        $processed[ $class ] = array(
+                            'version' => $source['version'],
+                            'path'    => call_user_func( $this->pathCodeTransformer, $path ),
+                        );
+                    }
+                }
+            }
+        }
+
+        /*
 		 * PSR-0 namespaces are converted to classmaps for both optimized and unoptimized autoloaders because any new
 		 * development should use classmap or PSR-4 autoloading.
 		 */
-		if ( ! empty( $autoloads['psr-0'] ) ) {
-			foreach ( $autoloads['psr-0'] as $namespace => $sources ) {
-				$namespace = empty( $namespace ) ? null : $namespace;
-
-				foreach ( $sources as $source ) {
-					$classmap = call_user_func( $this->classmapScanner, $source['path'], $excludedClasses, $namespace );
-					foreach ( $classmap as $class => $path ) {
-						$processed[ $class ] = array(
-							'version' => $source['version'],
-							'path'    => call_user_func( $this->pathCodeTransformer, $path ),
-						);
-					}
-				}
-			}
-		}
-
-		if ( ! empty( $autoloads['classmap'] ) ) {
-			foreach ( $autoloads['classmap'] as $package ) {
-				$classmap = call_user_func( $this->classmapScanner, $package['path'], $excludedClasses, null );
-
-				foreach ( $classmap as $class => $path ) {
-					$processed[ $class ] = array(
-						'version' => $package['version'],
-						'path'    => call_user_func( $this->pathCodeTransformer, $path ),
-					);
-				}
-			}
-		}
-
-		return $processed;
-	}
-
-	/**
-	 * Processes the PSR-4 autoloads into a relative path format including the version for each file.
-	 *
-	 * @param array $autoloads The autoloads we are processing.
-	 * @param bool  $scanPsrPackages Whether or not PSR packages should be converted to a classmap.
-	 *
-	 * @return array $processed
-	 */
-	public function processPsr4Packages( $autoloads, $scanPsrPackages ) {
-		if ( $scanPsrPackages || empty( $autoloads['psr-4'] ) ) {
-			return null;
-		}
-
-		$processed = array();
-
-		foreach ( $autoloads['psr-4'] as $namespace => $packages ) {
-			$namespace = empty( $namespace ) ? null : $namespace;
-			$paths     = array();
-
-			foreach ( $packages as $package ) {
-				$paths[] = call_user_func( $this->pathCodeTransformer, $package['path'] );
-			}
-
-			$processed[ $namespace ] = array(
-				'version' => $package['version'],
-				'path'    => $paths,
-			);
-		}
-
-		return $processed;
-	}
-
-	/**
-	 * Processes the file autoloads into a relative format including the version for each file.
-	 *
-	 * @param array $autoloads The autoloads we are processing.
-	 *
-	 * @return array|null $processed
-	 */
-	public function processFiles( $autoloads ) {
-		if ( empty( $autoloads['files'] ) ) {
-			return null;
-		}
-
-		$processed = array();
-
-		foreach ( $autoloads['files'] as $file_id => $package ) {
-			$processed[ $file_id ] = array(
-				'version' => $package['version'],
-				'path'    => call_user_func( $this->pathCodeTransformer, $package['path'] ),
-			);
-		}
-
-		return $processed;
-	}
+        if ( ! empty( $autoloads['psr-0'] ) ) {
+            foreach ( $autoloads['psr-0'] as $namespace => $sources ) {
+                $namespace = empty( $namespace ) ? null : $namespace;
+
+                foreach ( $sources as $source ) {
+                    $classmap = call_user_func( $this->classmapScanner, $source['path'], $excludedClasses, $namespace );
+                    foreach ( $classmap as $class => $path ) {
+                        $processed[ $class ] = array(
+                            'version' => $source['version'],
+                            'path'    => call_user_func( $this->pathCodeTransformer, $path ),
+                        );
+                    }
+                }
+            }
+        }
+
+        if ( ! empty( $autoloads['classmap'] ) ) {
+            foreach ( $autoloads['classmap'] as $package ) {
+                $classmap = call_user_func( $this->classmapScanner, $package['path'], $excludedClasses, null );
+
+                foreach ( $classmap as $class => $path ) {
+                    $processed[ $class ] = array(
+                        'version' => $package['version'],
+                        'path'    => call_user_func( $this->pathCodeTransformer, $path ),
+                    );
+                }
+            }
+        }
+
+        return $processed;
+    }
+
+    /**
+     * Processes the PSR-4 autoloads into a relative path format including the version for each file.
+     *
+     * @param array $autoloads The autoloads we are processing.
+     * @param bool  $scanPsrPackages Whether or not PSR packages should be converted to a classmap.
+     *
+     * @return array $processed
+     */
+    public function processPsr4Packages( $autoloads, $scanPsrPackages ) {
+        if ( $scanPsrPackages || empty( $autoloads['psr-4'] ) ) {
+            return null;
+        }
+
+        $processed = array();
+
+        foreach ( $autoloads['psr-4'] as $namespace => $packages ) {
+            $namespace = empty( $namespace ) ? null : $namespace;
+            $paths     = array();
+
+            foreach ( $packages as $package ) {
+                $paths[] = call_user_func( $this->pathCodeTransformer, $package['path'] );
+            }
+
+            $processed[ $namespace ] = array(
+                'version' => $package['version'],
+                'path'    => $paths,
+            );
+        }
+
+        return $processed;
+    }
+
+    /**
+     * Processes the file autoloads into a relative format including the version for each file.
+     *
+     * @param array $autoloads The autoloads we are processing.
+     *
+     * @return array|null $processed
+     */
+    public function processFiles( $autoloads ) {
+        if ( empty( $autoloads['files'] ) ) {
+            return null;
+        }
+
+        $processed = array();
+
+        foreach ( $autoloads['files'] as $file_id => $package ) {
+            $processed[ $file_id ] = array(
+                'version' => $package['version'],
+                'path'    => call_user_func( $this->pathCodeTransformer, $package['path'] ),
+            );
+        }
+
+        return $processed;
+    }
 }

Spacing +41 added lines, -41 removed lines

@@ -39,7 +39,7 @@ 
 	 * @param callable $classmapScanner A callable for scanning a directory for all of its classes.
 	 * @param callable $pathCodeTransformer A callable for transforming a path into one to be used in code.
 	 */
-	public function __construct( $classmapScanner, $pathCodeTransformer ) {
+	public function __construct($classmapScanner, $pathCodeTransformer) {
 		$this->classmapScanner     = $classmapScanner;
 		$this->pathCodeTransformer = $pathCodeTransformer;
 	}
@@ -52,34 +52,34 @@ 
 	 *
 	 * @return array $processed
 	 */
-	public function processClassmap( $autoloads, $scanPsrPackages ) {
+	public function processClassmap($autoloads, $scanPsrPackages) {
 		// We can't scan PSR packages if we don't actually have any.
-		if ( empty( $autoloads['psr-4'] ) ) {
+		if (empty($autoloads['psr-4'])) {
 			$scanPsrPackages = false;
 		}
 
-		if ( empty( $autoloads['classmap'] ) && ! $scanPsrPackages ) {
+		if (empty($autoloads['classmap']) && !$scanPsrPackages) {
 			return null;
 		}
 
 		$excludedClasses = null;
-		if ( ! empty( $autoloads['exclude-from-classmap'] ) ) {
-			$excludedClasses = '{(' . implode( '|', $autoloads['exclude-from-classmap'] ) . ')}';
+		if (!empty($autoloads['exclude-from-classmap'])) {
+			$excludedClasses = '{(' . implode('|', $autoloads['exclude-from-classmap']) . ')}';
 		}
 
 		$processed = array();
 
-		if ( $scanPsrPackages ) {
-			foreach ( $autoloads['psr-4'] as $namespace => $sources ) {
-				$namespace = empty( $namespace ) ? null : $namespace;
+		if ($scanPsrPackages) {
+			foreach ($autoloads['psr-4'] as $namespace => $sources) {
+				$namespace = empty($namespace) ? null : $namespace;
 
-				foreach ( $sources as $source ) {
-					$classmap = call_user_func( $this->classmapScanner, $source['path'], $excludedClasses, $namespace );
+				foreach ($sources as $source) {
+					$classmap = call_user_func($this->classmapScanner, $source['path'], $excludedClasses, $namespace);
 
-					foreach ( $classmap as $class => $path ) {
-						$processed[ $class ] = array(
+					foreach ($classmap as $class => $path) {
+						$processed[$class] = array(
 							'version' => $source['version'],
-							'path'    => call_user_func( $this->pathCodeTransformer, $path ),
+							'path'    => call_user_func($this->pathCodeTransformer, $path),
 						);
 					}
 				}
@@ -90,30 +90,30 @@ 
 		 * PSR-0 namespaces are converted to classmaps for both optimized and unoptimized autoloaders because any new
 		 * development should use classmap or PSR-4 autoloading.
 		 */
-		if ( ! empty( $autoloads['psr-0'] ) ) {
-			foreach ( $autoloads['psr-0'] as $namespace => $sources ) {
-				$namespace = empty( $namespace ) ? null : $namespace;
-
-				foreach ( $sources as $source ) {
-					$classmap = call_user_func( $this->classmapScanner, $source['path'], $excludedClasses, $namespace );
-					foreach ( $classmap as $class => $path ) {
-						$processed[ $class ] = array(
+		if (!empty($autoloads['psr-0'])) {
+			foreach ($autoloads['psr-0'] as $namespace => $sources) {
+				$namespace = empty($namespace) ? null : $namespace;
+
+				foreach ($sources as $source) {
+					$classmap = call_user_func($this->classmapScanner, $source['path'], $excludedClasses, $namespace);
+					foreach ($classmap as $class => $path) {
+						$processed[$class] = array(
 							'version' => $source['version'],
-							'path'    => call_user_func( $this->pathCodeTransformer, $path ),
+							'path'    => call_user_func($this->pathCodeTransformer, $path),
 						);
 					}
 				}
 			}
 		}
 
-		if ( ! empty( $autoloads['classmap'] ) ) {
-			foreach ( $autoloads['classmap'] as $package ) {
-				$classmap = call_user_func( $this->classmapScanner, $package['path'], $excludedClasses, null );
+		if (!empty($autoloads['classmap'])) {
+			foreach ($autoloads['classmap'] as $package) {
+				$classmap = call_user_func($this->classmapScanner, $package['path'], $excludedClasses, null);
 
-				foreach ( $classmap as $class => $path ) {
-					$processed[ $class ] = array(
+				foreach ($classmap as $class => $path) {
+					$processed[$class] = array(
 						'version' => $package['version'],
-						'path'    => call_user_func( $this->pathCodeTransformer, $path ),
+						'path'    => call_user_func($this->pathCodeTransformer, $path),
 					);
 				}
 			}
@@ -130,22 +130,22 @@ 
 	 *
 	 * @return array $processed
 	 */
-	public function processPsr4Packages( $autoloads, $scanPsrPackages ) {
-		if ( $scanPsrPackages || empty( $autoloads['psr-4'] ) ) {
+	public function processPsr4Packages($autoloads, $scanPsrPackages) {
+		if ($scanPsrPackages || empty($autoloads['psr-4'])) {
 			return null;
 		}
 
 		$processed = array();
 
-		foreach ( $autoloads['psr-4'] as $namespace => $packages ) {
-			$namespace = empty( $namespace ) ? null : $namespace;
+		foreach ($autoloads['psr-4'] as $namespace => $packages) {
+			$namespace = empty($namespace) ? null : $namespace;
 			$paths     = array();
 
-			foreach ( $packages as $package ) {
-				$paths[] = call_user_func( $this->pathCodeTransformer, $package['path'] );
+			foreach ($packages as $package) {
+				$paths[] = call_user_func($this->pathCodeTransformer, $package['path']);
 			}
 
-			$processed[ $namespace ] = array(
+			$processed[$namespace] = array(
 				'version' => $package['version'],
 				'path'    => $paths,
 			);
@@ -161,17 +161,17 @@ 
 	 *
 	 * @return array|null $processed
 	 */
-	public function processFiles( $autoloads ) {
-		if ( empty( $autoloads['files'] ) ) {
+	public function processFiles($autoloads) {
+		if (empty($autoloads['files'])) {
 			return null;
 		}
 
 		$processed = array();
 
-		foreach ( $autoloads['files'] as $file_id => $package ) {
-			$processed[ $file_id ] = array(
+		foreach ($autoloads['files'] as $file_id => $package) {
+			$processed[$file_id] = array(
 				'version' => $package['version'],
-				'path'    => call_user_func( $this->pathCodeTransformer, $package['path'] ),
+				'path'    => call_user_func($this->pathCodeTransformer, $package['path']),
 			);
 		}