ComposerLink\DependencyResolver::resolveForPackage()

Complexity

Conditions	4
Paths	12

Size

Total Lines	52
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

<?php
    public function resolveForPackage(LinkedPackage $package): array
    {
        // TODO use configuration of original composer.json
        $repositorySet = new RepositorySet(
            'dev',
            [],
            [],
        );

        // TODO we can't use this
        $exexutor = new ProcessExecutor($this->io);
        $exexutor->enableAsync();

        // Fill repositories first the root package repository
        $repositorySet->addRepository(new RootPackageRepository($this->composer->getPackage()));

        // The locked repository, we don't do a full upgrade, so we want to keep as much as possible packages up to date
        $repositorySet->addRepository($this->composer->getLocker()->getLockedRepository(true));

        // No we add our custom path repositories, we  need to do this before we add the original repositories
        // otherwise we do not get precedence over the other repositories
        $repo = new PathRepository(['url' => $package->getPath()], $this->io, $this->composer->getConfig(), null, null, $exexutor);
        $repositorySet->addRepository($repo);

        // Add custom repositories defined in the composer file
        $repositories = $this->composer->getRepositoryManager()->getRepositories();
        foreach ($repositories as $repository) {
            $repositorySet->addRepository($repository);
        }

        // Make request for package, and fix all the currently existing packages
        $request = new Request();
        $request->requireName($package->getName(), new Constraint('=', 'dev-master'));
        foreach ($this->composer->getRepositoryManager()->getLocalRepository()->getPackages() as $localPackage) {
            $request->fixPackage($localPackage);
        }
        $policy = new DefaultPolicy(true);

        // Create pool and solve?
        $pool = $repositorySet->createPool($request, $this->io);
        $solver = new Solver($policy, $pool, $this->io);

        $operations = [];

        try {
            $transaction = $solver->solve($request, PlatformRequirementFilterFactory::ignoreAll());
            $operations = $transaction->getOperations();
        } catch (SolverProblemsException $exception) {
            $this->io->write($exception->getPrettyString($repositorySet, $request, $pool, true));
        }

        return $operations;
    }