/**
  * {@inheritdoc}
  */
 public function activate(Composer $composer, IOInterface $io)
 {
     foreach (static::$types as $type) {
         $installer = new WordpressInstaller($io, $composer, $type);
         $composer->getInstallationManager()->addInstaller($installer);
     }
 }

 public function activate(Composer $composer, IOInterface $io)
 {
     $this->io = $io;
     $vendor = $composer->getConfig()->get('vendor-dir', '/');
     $this->vendor = $vendor;
     $this->root = dirname($vendor);
 }

    public function setUp()
    {
        $this->config = $this->getMock('Composer\Config');
        $this->config->expects($this->any())
            ->method('get')
            ->will($this->returnCallback(function ($key) {
                switch ($key) {
                    case 'cache-repo-dir':
                        return sys_get_temp_dir() . '/composer-test-repo-cache';
                    case 'vendor-dir':
                        return sys_get_temp_dir() . '/composer-test/vendor';
                }

                return null;
            }));

        $this->rootPackage = $this->getMock('Composer\Package\RootPackageInterface');
        $this->package = $this->getMock('Composer\Package\PackageInterface');
        $this->package->expects($this->any())
            ->method('getName')
            ->will($this->returnValue('foo-asset/foo'));

        $this->composer = $this->getMock('Composer\Composer');
        $this->composer->expects($this->any())
            ->method('getPackage')
            ->will($this->returnValue($this->rootPackage));
        $this->composer->expects($this->any())
            ->method('getConfig')
            ->will($this->returnValue($this->config));
    }

 public function testSetGetInstallationManager()
 {
     $composer = new Composer();
     $manager = $this->getMock('Composer\\Installer\\InstallationManager');
     $composer->setInstallationManager($manager);
     $this->assertSame($manager, $composer->getInstallationManager());
 }

 /**
  * @param Composer $composer
  * @param IOInterface $io
  */
 public function activate(Composer $composer, IOInterface $io)
 {
     $repositoryManager = $composer->getRepositoryManager();
     $extra = $composer->getPackage()->getExtra();
     if (!isset($extra['connect-packages'])) {
         return;
     }
     $versionParser = new VersionParser();
     $links = [];
     foreach ($extra['connect-packages'] as $connectPackage => $version) {
         try {
             $releases = $this->getVersionsForPackage($connectPackage);
         } catch (InvalidArgumentException $e) {
             $message = '<error>Could not find release manifest for module with extension key: "%s". ';
             $message .= 'Did you get the casing right? Error: "%s"</error>';
             $io->writeError(sprintf($message, $connectPackage, $e->getMessage()), true);
             continue;
         } catch (UnexpectedValueException $e) {
             $message = '<error>Non valid XML return from connect for module with extension key: "%s".</error>';
             $message .= $e->getMessage();
             $io->writeError(sprintf($message, $connectPackage), true);
             continue;
         }
         $repository = $this->addPackages($releases, $connectPackage);
         $repositoryManager->addRepository($repository);
         $constraint = $versionParser->parseConstraints($version);
         $links[] = new Link($composer->getPackage()->getName(), $connectPackage, $constraint);
     }
     if (!empty($links)) {
         $requires = $composer->getPackage()->getRequires();
         $requires = array_merge($requires, $links);
         $composer->getPackage()->setRequires($requires);
     }
 }

 /**
  * {@inheritDoc}
  */
 public function activate(Composer $composer, IOInterface $io)
 {
     $pluginInstaller = new PluginInstaller($io, $composer);
     $composer->getInstallationManager()->addInstaller($pluginInstaller);
     //$themeInstaller = new ThemeInstaller($io, $composer);
     //$composer->getInstallationManager()->addInstaller($themeInstaller);
 }

 /**
  * Test getLocations returning appropriate values based on CakePHP version
  *
  */
 public function testGetLocations()
 {
     $package = new RootPackage('CamelCased', '1.0', '1.0');
     $composer = new Composer();
     $rm = new RepositoryManager($this->getMock('Composer\\IO\\IOInterface'), $this->getMock('Composer\\Config'));
     $composer->setRepositoryManager($rm);
     $installer = new CakePHPInstaller($package, $composer);
     // 2.0 < cakephp < 3.0
     $this->setCakephpVersion($rm, '2.0.0');
     $result = $installer->getLocations();
     $this->assertContains('Plugin/', $result['plugin']);
     $this->setCakephpVersion($rm, '2.5.9');
     $result = $installer->getLocations();
     $this->assertContains('Plugin/', $result['plugin']);
     $this->setCakephpVersion($rm, '~2.5');
     $result = $installer->getLocations();
     $this->assertContains('Plugin/', $result['plugin']);
     // special handling for 2.x versions when 3.x is still in development
     $this->setCakephpVersion($rm, 'dev-master');
     $result = $installer->getLocations();
     $this->assertContains('Plugin/', $result['plugin']);
     $this->setCakephpVersion($rm, '>=2.5');
     $result = $installer->getLocations();
     $this->assertContains('Plugin/', $result['plugin']);
     // cakephp >= 3.0
     $this->setCakephpVersion($rm, '3.0.*-dev');
     $result = $installer->getLocations();
     $this->assertContains('plugins/', $result['plugin']);
     $this->setCakephpVersion($rm, '~8.8');
     $result = $installer->getLocations();
     $this->assertContains('plugins/', $result['plugin']);
 }

 public function activate(Composer $composer, IOInterface $io)
 {
     // Add the Innomatic legacy platform installer
     $composer->getInstallationManager()->addInstaller(new LegacyPlatformInstaller($io, $composer));
     // Add the Innomatic legacy application installer
     $composer->getInstallationManager()->addInstaller(new LegacyApplicationInstaller($io, $composer));
 }

 /**
  * @param \Composer\Composer $composer
  * @param \Composer\Util\Filesystem $filesystem
  */
 public function __construct(\Composer\Composer $composer, \Composer\Util\Filesystem $filesystem = NULL)
 {
     $this->composer = $composer;
     $this->downloadManager = $composer->getDownloadManager();
     $this->filesystem = $filesystem ?: new \Composer\Util\Filesystem();
     $this->extensionDir = self::TYPO3_CONF_DIR . DIRECTORY_SEPARATOR . self::TYPO3_EXT_DIR;
 }

 private function createComposerInstance()
 {
     $composer = new Composer();
     $config = new Config();
     $composer->setConfig($config);
     return $composer;
 }

 public static function getPackageInstallPath(PackageInterface $package, Composer $composer)
 {
     $prettyName = $package->getPrettyName();
     if (strpos($prettyName, '/') !== false) {
         list($vendor, $name) = explode('/', $prettyName);
     } else {
         $vendor = '';
         $name = $prettyName;
     }
     $availableVars = compact('name', 'vendor');
     $extra = $package->getExtra();
     if (!empty($extra['installer-name'])) {
         $availableVars['name'] = $extra['installer-name'];
     }
     if ($composer->getPackage()) {
         $extra = $composer->getPackage()->getExtra();
         if (!empty($extra['installer-paths'])) {
             $customPath = self::mapCustomInstallPaths($extra['installer-paths'], $prettyName);
             if (false !== $customPath) {
                 return self::templatePath($customPath, $availableVars);
             }
         }
     }
     return NULL;
 }

 /**
  * Call extra recursive
  * @param Composer $composer
  * @param IExtra $extra
  */
 private function callRecursive(Composer $composer, IExtra $extra)
 {
     $extra->run($composer->getPackage(), true);
     foreach ($composer->getRepositoryManager()->getLocalRepository()->getPackages() as $package) {
         $extra->run($package, false);
     }
 }

 public function activate(Composer $composer, IO\IOInterface $io)
 {
     $this->composer = $composer;
     $this->config = $composer->getConfig();
     $this->io = $io;
     $this->pluginConfig = $this->setPluginConfig();
 }

 public static function getConsoleCommands(Composer $composer)
 {
     $commands = array(array('yiic', 'migrate'));
     if ($composer->getPackage()) {
         $extra = $composer->getPackage()->getExtra();
         if (!empty($extra['yiicomposer-console-commands'])) {
             $tmp = $extra['yiicomposer-console-commands'];
         }
         if (!empty($tmp)) {
             $commands = array();
             foreach ($tmp as $c) {
                 $command = array();
                 $command[] = 'yiic';
                 $command[] = $c['controller'];
                 if (!empty($c['action'])) {
                     $command[] = $c['action'];
                 }
                 if (!empty($c['params'])) {
                     $command = array_merge($command, $c['params']);
                 }
                 if (!empty($c['params'])) {
                     foreach ($c['params'] as $k => $v) {
                         $command[] = '--' . $k . '=' . $v;
                     }
                 }
                 $commands[] = $command;
             }
         }
     }
     return $commands;
 }

 public function __construct(PackageInterface $package = null, Composer $composer = null, IOInterface $io = null)
 {
     if (null === $package) {
         $package = $composer->getPackage();
     }
     $extraOxidRoot = $extraModuleVendor = false;
     if (null !== $package) {
         $extra = $package->getExtra();
         if (isset($extra['oxid-root'])) {
             foreach ($this->locations as $name => $location) {
                 $this->locations[$name] = "{$extra['oxid-root']}/{$location}";
             }
             $extraOxidRoot = true;
         }
         if (isset($extra['module-vendor'])) {
             $this->locations['module'] = str_replace('modules/', "modules/{$extra['module-vendor']}/", $this->locations['module']);
             $extraModuleVendor = true;
         }
     }
     $composerPackage = $composer->getPackage();
     if (null !== $composerPackage) {
         $extra = $composerPackage->getExtra();
         if (isset($extra['oxid-root']) && !$extraOxidRoot) {
             foreach ($this->locations as $name => $location) {
                 $this->locations[$name] = "{$extra['oxid-root']}/{$location}";
             }
         }
         if (isset($extra['module-vendor']) && !$extraModuleVendor) {
             $this->locations['module'] = str_replace('modules/', "modules/{$extra['module-vendor']}/", $this->locations['module']);
         }
     }
     parent::__construct($package, $composer, $io);
 }

 /**
  * Apply plugin modifications to composer
  * TODO: If we get updated by composer there will be 2 instances afterwards.
  * The old as Xinc\Composer\Plugin and the new one as Xinc\Composer\Plugin_composer_tmp0
  * So we activate 2 Installer.
  *
  * @param Composer $composer
  * @param IOInterface $io
  * @return void
  */
 public function activate(Composer $composer, IOInterface $io)
 {
     // Register our own installer
     $composer->getInstallationManager()->addInstaller(new Installer($io, $composer));
     $this->composer = $composer;
     $this->io = $io;
 }

 /**
  * @param \Composer\Composer
  * @param string
  * @param string
  */
 public function dumpFiles(Composer $composer, $paths, $targetDir = 'composer')
 {
     $installationManager = $composer->getInstallationManager();
     $localRepo = $composer->getRepositoryManager()->getLocalRepository();
     $mainPackage = $composer->getPackage();
     $config = $composer->getConfig();
     $filesystem = new Filesystem();
     $basePath = $filesystem->normalizePath(realpath(getcwd()));
     $vendorPath = $filesystem->normalizePath(realpath($config->get('vendor-dir')));
     $targetDir = $vendorPath . '/' . $targetDir;
     $vendorPathCode = $filesystem->findShortestPathCode(realpath($targetDir), $vendorPath, true);
     $vendorPathCode52 = str_replace('__DIR__', 'dirname(__FILE__)', $vendorPathCode);
     $appBaseDirCode = $filesystem->findShortestPathCode($vendorPath, $basePath, true);
     $appBaseDirCode = str_replace('__DIR__', '$vendorDir', $appBaseDirCode);
     $packageMap = $this->buildPackageMap($installationManager, $mainPackage, $localRepo->getCanonicalPackages());
     $autoloads = $this->parseAutoloads($packageMap, $mainPackage);
     $paths = $this->parseAutoloadsTypeFiles($paths, $mainPackage);
     $autoloads['files'] = array_merge($paths, $autoloads['files']);
     $includeFilesFilePath = $targetDir . '/autoload_files.php';
     if ($includeFilesFileContents = $this->getIncludeFilesFile($autoloads['files'], $filesystem, $basePath, $vendorPath, $vendorPathCode52, $appBaseDirCode)) {
         file_put_contents($includeFilesFilePath, $includeFilesFileContents);
     } elseif (file_exists($includeFilesFilePath)) {
         unlink($includeFilesFilePath);
     }
 }

 /**
  * Returns the PhantomJS version number.
  *
  * Firstly, we search for a version number in the local repository,
  * secondly, in the root package.
  * A version specification of "dev-master#<commit-reference>" is disallowed.
  *
  * @param Composer $composer
  * @return string $version Version
  */
 public static function getVersion($composer)
 {
     $packages = $composer->getRepositoryManager()->getLocalRepository()->getCanonicalPackages();
     $os = self::getOS();
     foreach ($packages as $package) {
         if ($package->getName() === 'triplekdev/phantomjs-installer') {
             $version = $package->getPrettyVersion();
         }
     }
     // version was not found in the local repository, let's take a look at the root package
     if ($version == null) {
         $version = self::getRequiredVersion($composer->getPackage(), 'triplekdev/phantomjs-installer');
     }
     // fallback to a hardcoded version number, if "dev-master" was set
     if ($version === 'dev-master') {
         return $os === 'macosx' ? '2.0.1' : '1.9.8';
     }
     // grab version from commit-reference, e.g. "dev-master#<commit-ref> as version"
     if (preg_match('/dev-master#(?:.*)(\\d.\\d.\\d)/i', $version, $matches)) {
         return $matches[1];
     }
     // grab version from a git version tag with a patch level, like "1.9.8-2"
     if (preg_match('/(\\d.\\d.\\d)(?:(?:-\\d)?)/i', $version, $matches)) {
         return $matches[1];
     }
     // grab version from a Composer patch version tag with a patch level, like "1.9.8-p02"
     if (preg_match('/(\\d.\\d.\\d)(?:(?:-p\\d{2})?)/i', $version, $matches)) {
         return $matches[1];
     }
     return $version;
 }

 /**
  * Activate Wordpress plugin
  *
  * @param Composer    $composer Composer
  * @param IOInterface $io       IO
  *
  * @return void
  */
 public function activate(Composer $composer, IOInterface $io)
 {
     $this->package = $composer->getPackage();
     $this->io = $io;
     // TODO: get the project root - must be a better way to do this
     $this->projectRoot = realpath(dirname($composer->getConfig()->get('vendor-dir')));
 }

 /**
  * @inheritdoc
  */
 public function activate(Composer $composer, IOInterface $io)
 {
     $this->io = $io;
     //Extend download manager
     $dm = $composer->getDownloadManager();
     $executor = new ProcessExecutor($io);
     $fs = new Filesystem($executor);
     $config = $composer->getConfig();
     $dm->setDownloader('svn-export', new Downloader($io, $config, $executor, $fs));
     //Extend RepositoryManager Classes
     $rm = $composer->getRepositoryManager();
     $rm->setRepositoryClass('svn-export', 'LinearSoft\\Composer\\SvnExport\\Repository\\VcsRepository');
     $rm->setRepositoryClass('svn-export-composer', 'LinearSoft\\Composer\\SvnExport\\Repository\\ComposerRepository');
     //Load Extra Data
     $extra = $composer->getPackage()->getExtra();
     if (isset($extra['svn-export-repositories']) && is_array($extra['svn-export-repositories'])) {
         foreach ($extra['svn-export-repositories'] as $index => $repoConfig) {
             $this->validateRepositories($index, $repoConfig);
             if (isset($repoConfig['name'])) {
                 $name = $repoConfig['name'];
             } else {
                 $name = is_int($index) ? preg_replace('{^https?://}i', '', $repoConfig['url']) : $index;
             }
             if ($repoConfig['type'] === 'svn') {
                 $repoConfig['type'] = 'svn-export';
             } else {
                 $repoConfig['type'] = 'svn-export-composer';
             }
             $repo = $rm->createRepository($repoConfig['type'], $repoConfig);
             $rm->addRepository($repo);
             $this->io->write("Added SvnExport repo: {$name}");
         }
     }
 }