AutoloadGenerator.php — MailPoet – Newsletters, Email Marketing, and Automation 5.34.3

mailpoet / vendor / automattic / jetpack-autoloader / src / AutoloadGenerator.php

mailpoet / vendor / automattic / jetpack-autoloader / src Last commit date

AutoloadGenerator.php

242 lines

1	<?php
2	namespace Automattic\Jetpack\Autoloader;
3	if (!defined('ABSPATH')) exit;
4	use Composer\Composer;
5	use Composer\Config;
6	use Composer\Installer\InstallationManager;
7	use Composer\IO\IOInterface;
8	use Composer\Package\PackageInterface;
9	use Composer\Repository\InstalledRepositoryInterface;
10	use Composer\Util\Filesystem;
11	use Composer\Util\PackageSorter;
12	class AutoloadGenerator {
13	const VERSION = '5.0.8';
14	private $io;
15	private $filesystem;
16	public function __construct( IOInterface $io ) {
17	$this->io = $io;
18	$this->filesystem = new Filesystem();
19	}
20	public function dump(
21	Composer $composer,
22	Config $config,
23	InstalledRepositoryInterface $localRepo,
24	PackageInterface $mainPackage,
25	InstallationManager $installationManager,
26	$targetDir,
27	$scanPsrPackages = false,
28	$suffix = null
29	) {
30	$this->filesystem->ensureDirectoryExists( $config->get( 'vendor-dir' ) );
31	$packageMap = $composer->getAutoloadGenerator()->buildPackageMap( $installationManager, $mainPackage, $localRepo->getCanonicalPackages() );
32	$autoloads = $this->parseAutoloads( $packageMap, $mainPackage );
33	// Convert the autoloads into a format that the manifest generator can consume more easily.
34	$basePath = $this->filesystem->normalizePath( realpath( getcwd() ) );
35	$vendorPath = $this->filesystem->normalizePath( realpath( $config->get( 'vendor-dir' ) ) );
36	$processedAutoloads = $this->processAutoloads( $autoloads, $scanPsrPackages, $vendorPath, $basePath );
37	unset( $packageMap, $autoloads );
38	// Make sure none of the legacy files remain that can lead to problems with the autoloader.
39	$this->removeLegacyFiles( $vendorPath );
40	// Write all of the files now that we're done.
41	$this->writeAutoloaderFiles( $vendorPath . '/jetpack-autoloader/', $suffix );
42	$this->writeManifests( $vendorPath . '/' . $targetDir, $processedAutoloads );
43	if ( ! $scanPsrPackages ) {
44	$this->io->writeError( '<warning>You are generating an unoptimized autoloader. If this is a production build, consider using the -o option.</warning>' );
45	}
46	}
47	public function parseAutoloads( array $packageMap, PackageInterface $mainPackage ) {
48	$rootPackageMap = array_shift( $packageMap );
49	$sortedPackageMap = $this->sortPackageMap( $packageMap );
50	$sortedPackageMap[] = $rootPackageMap;
51	array_unshift( $packageMap, $rootPackageMap );
52	$psr0 = $this->parseAutoloadsType( $packageMap, 'psr-0', $mainPackage );
53	$psr4 = $this->parseAutoloadsType( $packageMap, 'psr-4', $mainPackage );
54	$classmap = $this->parseAutoloadsType( array_reverse( $sortedPackageMap ), 'classmap', $mainPackage );
55	$files = $this->parseAutoloadsType( $sortedPackageMap, 'files', $mainPackage );
56	krsort( $psr0 );
57	krsort( $psr4 );
58	return array(
59	'psr-0' => $psr0,
60	'psr-4' => $psr4,
61	'classmap' => $classmap,
62	'files' => $files,
63	);
64	}
65	protected function sortPackageMap( array $packageMap ) {
66	$packages = array();
67	$paths = array();
68	foreach ( $packageMap as $item ) {
69	list( $package, $path ) = $item;
70	$name = $package->getName();
71	$packages[ $name ] = $package;
72	$paths[ $name ] = $path;
73	}
74	$sortedPackages = PackageSorter::sortPackages( $packages );
75	$sortedPackageMap = array();
76	foreach ( $sortedPackages as $package ) {
77	$name = $package->getName();
78	$sortedPackageMap[] = array( $packages[ $name ], $paths[ $name ] );
79	}
80	return $sortedPackageMap;
81	}
82	protected function getFileIdentifier( PackageInterface $package, $path ) {
83	return md5( $package->getName() . ':' . $path );
84	}
85	protected function getPathCode( Filesystem $filesystem, $basePath, $vendorPath, $path ) {
86	if ( ! $filesystem->isAbsolutePath( $path ) ) {
87	$path = $basePath . '/' . $path;
88	}
89	$path = $filesystem->normalizePath( $path );
90	$baseDir = '';
91	if ( 0 === strpos( $path . '/', $vendorPath . '/' ) ) {
92	$path = substr( $path, strlen( $vendorPath ) );
93	$baseDir = '$vendorDir';
94	if ( false !== $path ) {
95	$baseDir .= ' . ';
96	}
97	} else {
98	$path = $filesystem->normalizePath( $filesystem->findShortestPath( $basePath, $path, true ) );
99	if ( ! $filesystem->isAbsolutePath( $path ) ) {
100	$baseDir = '$baseDir . ';
101	$path = '/' . $path;
102	}
103	}
104	if ( strpos( $path, '.phar' ) !== false ) {
105	$baseDir = "'phar://' . " . $baseDir;
106	}
107	// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_var_export
108	return $baseDir . ( ( false !== $path ) ? var_export( $path, true ) : '' );
109	}
110	protected function parseAutoloadsType( array $packageMap, $type, PackageInterface $mainPackage ) {
111	$autoloads = array();
112	foreach ( $packageMap as $item ) {
113	list($package, $installPath) = $item;
114	$autoload = $package->getAutoload();
115	$version = $package->getVersion(); // Version of the class comes from the package - should we try to parse it?
116	// Store our own actual package version, not "dev-trunk" or whatever.
117	if ( $package->getName() === 'automattic/jetpack-autoloader' ) {
118	$version = self::VERSION;
119	}
120	if ( $package === $mainPackage ) {
121	$autoload = array_merge_recursive( $autoload, $package->getDevAutoload() );
122	}
123	if ( null !== $package->getTargetDir() && $package !== $mainPackage ) {
124	$installPath = substr( $installPath, 0, -strlen( '/' . $package->getTargetDir() ) );
125	}
126	if ( in_array( $type, array( 'psr-4', 'psr-0' ), true ) && isset( $autoload[ $type ] ) && is_array( $autoload[ $type ] ) ) {
127	foreach ( $autoload[ $type ] as $namespace => $paths ) {
128	$paths = is_array( $paths ) ? $paths : array( $paths );
129	foreach ( $paths as $path ) {
130	$relativePath = empty( $installPath ) ? ( empty( $path ) ? '.' : $path ) : $installPath . '/' . $path;
131	$autoloads[ $namespace ][] = array(
132	'path' => $relativePath,
133	'version' => $version,
134	);
135	}
136	}
137	}
138	if ( 'classmap' === $type && isset( $autoload['classmap'] ) && is_array( $autoload['classmap'] ) ) {
139	foreach ( $autoload['classmap'] as $paths ) {
140	$paths = is_array( $paths ) ? $paths : array( $paths );
141	foreach ( $paths as $path ) {
142	$relativePath = empty( $installPath ) ? ( empty( $path ) ? '.' : $path ) : $installPath . '/' . $path;
143	$autoloads[] = array(
144	'path' => $relativePath,
145	'version' => $version,
146	);
147	}
148	}
149	}
150	if ( 'files' === $type && isset( $autoload['files'] ) && is_array( $autoload['files'] ) ) {
151	foreach ( $autoload['files'] as $paths ) {
152	$paths = is_array( $paths ) ? $paths : array( $paths );
153	foreach ( $paths as $path ) {
154	$relativePath = empty( $installPath ) ? ( empty( $path ) ? '.' : $path ) : $installPath . '/' . $path;
155	$autoloads[ $this->getFileIdentifier( $package, $path ) ] = array(
156	'path' => $relativePath,
157	'version' => $version,
158	);
159	}
160	}
161	}
162	}
163	return $autoloads;
164	}
165	private function processAutoloads( $autoloads, $scanPsrPackages, $vendorPath, $basePath ) {
166	$processor = new AutoloadProcessor(
167	function ( $path, $excludedClasses, $namespace ) use ( $basePath ) {
168	$dir = $this->filesystem->normalizePath(
169	$this->filesystem->isAbsolutePath( $path ) ? $path : $basePath . '/' . $path
170	);
171	// Composer 2.4 changed the name of the class.
172	if ( class_exists( \Composer\ClassMapGenerator\ClassMapGenerator::class ) ) {
173	if ( ! is_dir( $dir ) && ! is_file( $dir ) ) {
174	return array();
175	}
176	$generator = new \Composer\ClassMapGenerator\ClassMapGenerator();
177	$generator->scanPaths( $dir, $excludedClasses, 'classmap', empty( $namespace ) ? null : $namespace );
178	return $generator->getClassMap()->getMap();
179	}
180	return \Composer\Autoload\ClassMapGenerator::createMap(
181	$dir,
182	$excludedClasses,
183	null, // Don't pass the IOInterface since the normal autoload generation will have reported already.
184	empty( $namespace ) ? null : $namespace
185	);
186	},
187	function ( $path ) use ( $basePath, $vendorPath ) {
188	return $this->getPathCode( $this->filesystem, $basePath, $vendorPath, $path );
189	}
190	);
191	return array(
192	'psr-4' => $processor->processPsr4Packages( $autoloads, $scanPsrPackages ),
193	'classmap' => $processor->processClassmap( $autoloads, $scanPsrPackages ),
194	'files' => $processor->processFiles( $autoloads ),
195	);
196	}
197	private function removeLegacyFiles( $outDir ) {
198	$files = array(
199	'autoload_functions.php',
200	'class-autoloader-handler.php',
201	'class-classes-handler.php',
202	'class-files-handler.php',
203	'class-plugins-handler.php',
204	'class-version-selector.php',
205	);
206	foreach ( $files as $file ) {
207	$this->filesystem->remove( $outDir . '/' . $file );
208	}
209	}
210	private function writeAutoloaderFiles( $outDir, $suffix ) {
211	$this->io->writeError( "<info>Generating jetpack autoloader ($outDir)</info>" );
212	// We will remove all autoloader files to generate this again.
213	$this->filesystem->emptyDirectory( $outDir );
214	// Write the autoloader files.
215	AutoloadFileWriter::copyAutoloaderFiles( $this->io, $outDir, $suffix );
216	}
217	private function writeManifests( $outDir, $processedAutoloads ) {
218	$this->io->writeError( "<info>Generating jetpack autoloader manifests ($outDir)</info>" );
219	$manifestFiles = array(
220	'classmap' => 'jetpack_autoload_classmap.php',
221	'psr-4' => 'jetpack_autoload_psr4.php',
222	'files' => 'jetpack_autoload_filemap.php',
223	);
224	foreach ( $manifestFiles as $key => $file ) {
225	// Make sure the file doesn't exist so it isn't there if we don't write it.
226	$this->filesystem->remove( $outDir . '/' . $file );
227	if ( empty( $processedAutoloads[ $key ] ) ) {
228	continue;
229	}
230	$content = ManifestGenerator::buildManifest( $key, $file, $processedAutoloads[ $key ] );
231	if ( empty( $content ) ) {
232	continue;
233	}
234	if ( file_put_contents( $outDir . '/' . $file, $content ) ) {
235	$this->io->writeError( " <info>Generated: $file</info>" );
236	} else {
237	$this->io->writeError( " <error>Error: $file</error>" );
238	}
239	}
240	}
241	}
242