Symlink packages after composer update

This is a fundamental rewrite of the Composer integration. Now, instead
of adding the loaded paths to Composer's search path (by creating path
repositories for them), we replace the packages downloaded by Composer
that can be found in the loaded paths by symlinks to the local paths.

Doing so requires us to hook into the autoload dumper, which now has to
respect the rules in the local path, not those obtained from Packagist.

All of this should hopefully fix several issues, most importantly:
- Composer's lock file will be written before Studio does its magic,
  therefore not causing any conflicts with other developers' setups.
- Different version constraints on symlinked packages won't cause
  problems anymore. Any required packages that are found in loaded paths
  will be loaded, no matter the branch or version they are on.

Open questions:
- How should packages be handled that have not yet been added to
  Packagist? (Proposed solution: Create path repositories for the loaded
  paths, but *append* them instead of *prepending*, so that they will
  only be used as fallback, if Packagist does not yield any results.)
- Should we validate the constraints from composer.json before creating
  symlinks? With this setup, everything might be working locally, but
  not when downloading the package from Packagist (as another version
  may be downloaded instead).

Refs #52, #58, #65, #72.

Author: franzliedke

src/Composer/StudioPlugin.php

@@ -5,11 +5,16 @@
 use Composer\Composer;
 use Composer\EventDispatcher\EventSubscriberInterface;
 use Composer\IO\IOInterface;
+use Composer\Json\JsonFile;
+use Composer\Package\PackageInterface;
 use Composer\Plugin\PluginInterface;
+use Composer\Repository\CompositeRepository;
+use Composer\Repository\InstalledFilesystemRepository;
 use Composer\Repository\PathRepository;
+use Composer\Repository\WritableRepositoryInterface;
 use Composer\Script\ScriptEvents;
+use Composer\Util\Filesystem;
 use Studio\Config\Config;
-use Studio\Config\FileStorage;
 
 class StudioPlugin implements PluginInterface, EventSubscriberInterface
 {
@@ -31,32 +36,121 @@ public function activate(Composer $composer, IOInterface $io)
 
     public static function getSubscribedEvents()
     {
+        // TODO: Before update, append Studio path repositories
         return [
-            ScriptEvents::PRE_INSTALL_CMD => 'registerStudioPackages',
-            ScriptEvents::PRE_UPDATE_CMD => 'registerStudioPackages',
+            ScriptEvents::POST_UPDATE_CMD => 'symlinkStudioPackages',
+            ScriptEvents::PRE_AUTOLOAD_DUMP => 'loadStudioPackagesForDump',
         ];
     }
 
     /**
-     * Register all managed paths with Composer.
+     * Symlink all Studio-managed packages
      *
-     * This function configures Composer to treat all Studio-managed paths as local path repositories, so that packages
-     * therein will be symlinked directly.
+     * After `composer update`, we replace all packages that can also be found
+     * in paths managed by Studio with symlinks to those paths.
      */
-    public function registerStudioPackages()
+    public function symlinkStudioPackages()
+    {
+        $intersection = $this->getManagedPackages();
+
+        // Create symlinks for all left-over packages in vendor/composer/studio
+        $destination = $this->composer->getConfig()->get('vendor-dir') . '/composer/studio';
+        (new Filesystem())->emptyDirectory($destination);
+        $studioRepo = new InstalledFilesystemRepository(
+            new JsonFile($destination . '/installed.json')
+        );
+
+        $installationManager = $this->composer->getInstallationManager();
+
+        // Get local repository which contains all installed packages
+        $installed = $this->composer->getRepositoryManager()->getLocalRepository();
+
+        foreach ($intersection as $package) {
+            $original = $installed->findPackage($package->getName(), '*');
+
+            $installationManager->getInstaller($original->getType())
+                ->uninstall($installed, $original);
+
+            $installationManager->getInstaller($package->getType())
+                ->install($studioRepo, $package);
+        }
+
+        $studioRepo->write();
+
+        // TODO: Run dump-autoload again
+    }
+
+    public function loadStudioPackagesForDump()
+    {
+        $localRepo = $this->composer->getRepositoryManager()->getLocalRepository();
+        $intersection = $this->getManagedPackages();
+
+        $packagesToReplace = [];
+        foreach ($intersection as $package) {
+            $packagesToReplace[] = $package->getName();
+        }
+
+        // Remove all packages with same names as one of symlinked packages
+        $packagesToRemove = [];
+        foreach ($localRepo->getCanonicalPackages() as $package) {
+            if (in_array($package->getName(), $packagesToReplace)) {
+                $packagesToRemove[] = $package;
+            }
+        }
+        foreach ($packagesToRemove as $package) {
+            $localRepo->removePackage($package);
+        }
+
+        // Add symlinked packages to local repository
+        foreach ($intersection as $package) {
+            $localRepo->addPackage(clone $package);
+        }
+    }
+
+    /**
+     * @param WritableRepositoryInterface $installedRepo
+     * @param PathRepository[] $managedRepos
+     * @return PackageInterface[]
+     */
+    private function getIntersection(WritableRepositoryInterface $installedRepo, $managedRepos)
+    {
+        $managedRepo = new CompositeRepository($managedRepos);
+
+        return array_filter(
+            array_map(
+                function (PackageInterface $package) use ($managedRepo) {
+                    return $managedRepo->findPackage($package->getName(), '*');
+                },
+                $installedRepo->getCanonicalPackages()
+            )
+        );
+    }
+
+    private function getManagedPackages()
     {
-        $repoManager = $this->composer->getRepositoryManager();
         $composerConfig = $this->composer->getConfig();
 
+        // Get array of PathRepository instances for Studio-managed paths
+        $managed = [];
         foreach ($this->getManagedPaths() as $path) {
-            $this->io->writeError("[Studio] Loading path $path");
-
-            $repoManager->prependRepository(new PathRepository(
+            $managed[] = new PathRepository(
                 ['url' => $path],
                 $this->io,
                 $composerConfig
-            ));
+            );
+        }
+
+        // Intersect PathRepository packages with local repository
+        $intersection = $this->getIntersection(
+            $this->composer->getRepositoryManager()->getLocalRepository(),
+            $managed
+        );
+
+        foreach ($intersection as $package) {
+            $this->write('Loading package ' . $package->getUniqueName());
         }
+
+        return $intersection;
     }
 
     /**
@@ -71,4 +165,9 @@ private function getManagedPaths()
 
         return $config->getPaths();
     }
+
+    private function write($msg)
+    {
+        $this->io->writeError("[Studio] $msg");
+    }
 }