--- /dev/null
+<?php
+/**
+ * This file is part of the Composer Merge plugin.
+ *
+ * Copyright (C) 2015 Bryan Davis, Wikimedia Foundation, and contributors
+ *
+ * This software may be modified and distributed under the terms of the MIT
+ * license. See the LICENSE file for details.
+ */
+
+namespace Wikimedia\Composer\Merge;
+
+use Wikimedia\Composer\Logger;
+
+use Composer\Composer;
+use Composer\Json\JsonFile;
+use Composer\Package\BasePackage;
+use Composer\Package\CompletePackage;
+use Composer\Package\Link;
+use Composer\Package\Loader\ArrayLoader;
+use Composer\Package\RootAliasPackage;
+use Composer\Package\RootPackage;
+use Composer\Package\RootPackageInterface;
+use Composer\Package\Version\VersionParser;
+use UnexpectedValueException;
+
+/**
+ * Processing for a composer.json file that will be merged into
+ * a RootPackageInterface
+ *
+ * @author Bryan Davis <bd808@bd808.com>
+ */
+class ExtraPackage
+{
+
+ /**
+ * @var Composer $composer
+ */
+ protected $composer;
+
+ /**
+ * @var Logger $logger
+ */
+ protected $logger;
+
+ /**
+ * @var string $path
+ */
+ protected $path;
+
+ /**
+ * @var array $json
+ */
+ protected $json;
+
+ /**
+ * @var CompletePackage $package
+ */
+ protected $package;
+
+ /**
+ * @var VersionParser $versionParser
+ */
+ protected $versionParser;
+
+ /**
+ * @param string $path Path to composer.json file
+ * @param Composer $composer
+ * @param Logger $logger
+ */
+ public function __construct($path, Composer $composer, Logger $logger)
+ {
+ $this->path = $path;
+ $this->composer = $composer;
+ $this->logger = $logger;
+ $this->json = $this->readPackageJson($path);
+ $this->package = $this->loadPackage($this->json);
+ $this->versionParser = new VersionParser();
+ }
+
+ /**
+ * Get list of additional packages to include if precessing recursively.
+ *
+ * @return array
+ */
+ public function getIncludes()
+ {
+ return isset($this->json['extra']['merge-plugin']['include']) ?
+ $this->json['extra']['merge-plugin']['include'] : array();
+ }
+
+ /**
+ * Get list of additional packages to require if precessing recursively.
+ *
+ * @return array
+ */
+ public function getRequires()
+ {
+ return isset($this->json['extra']['merge-plugin']['require']) ?
+ $this->json['extra']['merge-plugin']['require'] : array();
+ }
+
+ /**
+ * Read the contents of a composer.json style file into an array.
+ *
+ * The package contents are fixed up to be usable to create a Package
+ * object by providing dummy "name" and "version" values if they have not
+ * been provided in the file. This is consistent with the default root
+ * package loading behavior of Composer.
+ *
+ * @param string $path
+ * @return array
+ */
+ protected function readPackageJson($path)
+ {
+ $file = new JsonFile($path);
+ $json = $file->read();
+ if (!isset($json['name'])) {
+ $json['name'] = 'merge-plugin/' .
+ strtr($path, DIRECTORY_SEPARATOR, '-');
+ }
+ if (!isset($json['version'])) {
+ $json['version'] = '1.0.0';
+ }
+ return $json;
+ }
+
+ /**
+ * @param array $json
+ * @return CompletePackage
+ */
+ protected function loadPackage(array $json)
+ {
+ $loader = new ArrayLoader();
+ $package = $loader->load($json);
+ // @codeCoverageIgnoreStart
+ if (!$package instanceof CompletePackage) {
+ throw new UnexpectedValueException(
+ 'Expected instance of CompletePackage, got ' .
+ get_class($package)
+ );
+ }
+ // @codeCoverageIgnoreEnd
+ return $package;
+ }
+
+ /**
+ * Merge this package into a RootPackageInterface
+ *
+ * @param RootPackageInterface $root
+ * @param PluginState $state
+ */
+ public function mergeInto(RootPackageInterface $root, PluginState $state)
+ {
+ $this->prependRepositories($root);
+
+ $this->mergeRequires('require', $root, $state);
+
+ $this->mergePackageLinks('conflict', $root);
+ $this->mergePackageLinks('replace', $root);
+ $this->mergePackageLinks('provide', $root);
+
+ $this->mergeSuggests($root);
+
+ $this->mergeAutoload('autoload', $root);
+
+ $this->mergeExtra($root, $state);
+
+ $this->mergeScripts($root, $state);
+
+ if ($state->isDevMode()) {
+ $this->mergeDevInto($root, $state);
+ } else {
+ $this->mergeReferences($root);
+ }
+ }
+
+ /**
+ * Merge just the dev portion into a RootPackageInterface
+ *
+ * @param RootPackageInterface $root
+ * @param PluginState $state
+ */
+ public function mergeDevInto(RootPackageInterface $root, PluginState $state)
+ {
+ $this->mergeRequires('require-dev', $root, $state);
+ $this->mergeAutoload('devAutoload', $root);
+ $this->mergeReferences($root);
+ }
+
+ /**
+ * Add a collection of repositories described by the given configuration
+ * to the given package and the global repository manager.
+ *
+ * @param RootPackageInterface $root
+ */
+ protected function prependRepositories(RootPackageInterface $root)
+ {
+ if (!isset($this->json['repositories'])) {
+ return;
+ }
+ $repoManager = $this->composer->getRepositoryManager();
+ $newRepos = array();
+
+ foreach ($this->json['repositories'] as $repoJson) {
+ if (!isset($repoJson['type'])) {
+ continue;
+ }
+ $this->logger->info("Prepending {$repoJson['type']} repository");
+ $repo = $repoManager->createRepository(
+ $repoJson['type'],
+ $repoJson
+ );
+ $repoManager->prependRepository($repo);
+ $newRepos[] = $repo;
+ }
+
+ $unwrapped = self::unwrapIfNeeded($root, 'setRepositories');
+ $unwrapped->setRepositories(array_merge(
+ $newRepos,
+ $root->getRepositories()
+ ));
+ }
+
+ /**
+ * Merge require or require-dev into a RootPackageInterface
+ *
+ * @param string $type 'require' or 'require-dev'
+ * @param RootPackageInterface $root
+ * @param PluginState $state
+ */
+ protected function mergeRequires(
+ $type,
+ RootPackageInterface $root,
+ PluginState $state
+ ) {
+ $linkType = BasePackage::$supportedLinkTypes[$type];
+ $getter = 'get' . ucfirst($linkType['method']);
+ $setter = 'set' . ucfirst($linkType['method']);
+
+ $requires = $this->package->{$getter}();
+ if (empty($requires)) {
+ return;
+ }
+
+ $this->mergeStabilityFlags($root, $requires);
+
+ $requires = $this->replaceSelfVersionDependencies(
+ $type,
+ $requires,
+ $root
+ );
+
+ $root->{$setter}($this->mergeOrDefer(
+ $type,
+ $root->{$getter}(),
+ $requires,
+ $state
+ ));
+ }
+
+ /**
+ * Merge two collections of package links and collect duplicates for
+ * subsequent processing.
+ *
+ * @param string $type 'require' or 'require-dev'
+ * @param array $origin Primary collection
+ * @param array $merge Additional collection
+ * @param PluginState $state
+ * @return array Merged collection
+ */
+ protected function mergeOrDefer(
+ $type,
+ array $origin,
+ array $merge,
+ $state
+ ) {
+ if ($state->ignoreDuplicateLinks() && $state->replaceDuplicateLinks()) {
+ $this->logger->warning("Both replace and ignore-duplicates are true. These are mutually exclusive.");
+ $this->logger->warning("Duplicate packages will be ignored.");
+ }
+
+ $dups = array();
+ foreach ($merge as $name => $link) {
+ if (isset($origin[$name]) && $state->ignoreDuplicateLinks()) {
+ $this->logger->info("Ignoring duplicate <comment>{$name}</comment>");
+ continue;
+ } elseif (!isset($origin[$name]) || $state->replaceDuplicateLinks()) {
+ $this->logger->info("Merging <comment>{$name}</comment>");
+ $origin[$name] = $link;
+ } else {
+ // Defer to solver.
+ $this->logger->info(
+ "Deferring duplicate <comment>{$name}</comment>"
+ );
+ $dups[] = $link;
+ }
+ }
+ $state->addDuplicateLinks($type, $dups);
+ return $origin;
+ }
+
+ /**
+ * Merge autoload or autoload-dev into a RootPackageInterface
+ *
+ * @param string $type 'autoload' or 'devAutoload'
+ * @param RootPackageInterface $root
+ */
+ protected function mergeAutoload($type, RootPackageInterface $root)
+ {
+ $getter = 'get' . ucfirst($type);
+ $setter = 'set' . ucfirst($type);
+
+ $autoload = $this->package->{$getter}();
+ if (empty($autoload)) {
+ return;
+ }
+
+ $unwrapped = self::unwrapIfNeeded($root, $setter);
+ $unwrapped->{$setter}(array_merge_recursive(
+ $root->{$getter}(),
+ $this->fixRelativePaths($autoload)
+ ));
+ }
+
+ /**
+ * Fix a collection of paths that are relative to this package to be
+ * relative to the base package.
+ *
+ * @param array $paths
+ * @return array
+ */
+ protected function fixRelativePaths(array $paths)
+ {
+ $base = dirname($this->path);
+ $base = ($base === '.') ? '' : "{$base}/";
+
+ array_walk_recursive(
+ $paths,
+ function (&$path) use ($base) {
+ $path = "{$base}{$path}";
+ }
+ );
+ return $paths;
+ }
+
+ /**
+ * Extract and merge stability flags from the given collection of
+ * requires and merge them into a RootPackageInterface
+ *
+ * @param RootPackageInterface $root
+ * @param array $requires
+ */
+ protected function mergeStabilityFlags(
+ RootPackageInterface $root,
+ array $requires
+ ) {
+ $flags = $root->getStabilityFlags();
+ $sf = new StabilityFlags($flags, $root->getMinimumStability());
+
+ $unwrapped = self::unwrapIfNeeded($root, 'setStabilityFlags');
+ $unwrapped->setStabilityFlags(array_merge(
+ $flags,
+ $sf->extractAll($requires)
+ ));
+ }
+
+ /**
+ * Merge package links of the given type into a RootPackageInterface
+ *
+ * @param string $type 'conflict', 'replace' or 'provide'
+ * @param RootPackageInterface $root
+ */
+ protected function mergePackageLinks($type, RootPackageInterface $root)
+ {
+ $linkType = BasePackage::$supportedLinkTypes[$type];
+ $getter = 'get' . ucfirst($linkType['method']);
+ $setter = 'set' . ucfirst($linkType['method']);
+
+ $links = $this->package->{$getter}();
+ if (!empty($links)) {
+ $unwrapped = self::unwrapIfNeeded($root, $setter);
+ // @codeCoverageIgnoreStart
+ if ($root !== $unwrapped) {
+ $this->logger->warning(
+ 'This Composer version does not support ' .
+ "'{$type}' merging for aliased packages."
+ );
+ }
+ // @codeCoverageIgnoreEnd
+ $unwrapped->{$setter}(array_merge(
+ $root->{$getter}(),
+ $this->replaceSelfVersionDependencies($type, $links, $root)
+ ));
+ }
+ }
+
+ /**
+ * Merge suggested packages into a RootPackageInterface
+ *
+ * @param RootPackageInterface $root
+ */
+ protected function mergeSuggests(RootPackageInterface $root)
+ {
+ $suggests = $this->package->getSuggests();
+ if (!empty($suggests)) {
+ $unwrapped = self::unwrapIfNeeded($root, 'setSuggests');
+ $unwrapped->setSuggests(array_merge(
+ $root->getSuggests(),
+ $suggests
+ ));
+ }
+ }
+
+ /**
+ * Merge extra config into a RootPackageInterface
+ *
+ * @param RootPackageInterface $root
+ * @param PluginState $state
+ */
+ public function mergeExtra(RootPackageInterface $root, PluginState $state)
+ {
+ $extra = $this->package->getExtra();
+ unset($extra['merge-plugin']);
+ if (!$state->shouldMergeExtra() || empty($extra)) {
+ return;
+ }
+
+ $rootExtra = $root->getExtra();
+ $unwrapped = self::unwrapIfNeeded($root, 'setExtra');
+
+ if ($state->replaceDuplicateLinks()) {
+ $unwrapped->setExtra(
+ self::mergeExtraArray($state->shouldMergeExtraDeep(), $rootExtra, $extra)
+ );
+ } else {
+ if (!$state->shouldMergeExtraDeep()) {
+ foreach (array_intersect(
+ array_keys($extra),
+ array_keys($rootExtra)
+ ) as $key) {
+ $this->logger->info(
+ "Ignoring duplicate <comment>{$key}</comment> in ".
+ "<comment>{$this->path}</comment> extra config."
+ );
+ }
+ }
+ $unwrapped->setExtra(
+ self::mergeExtraArray($state->shouldMergeExtraDeep(), $extra, $rootExtra)
+ );
+ }
+ }
+
+ /**
+ * Merge scripts config into a RootPackageInterface
+ *
+ * @param RootPackageInterface $root
+ * @param PluginState $state
+ */
+ public function mergeScripts(RootPackageInterface $root, PluginState $state)
+ {
+ $scripts = $this->package->getScripts();
+ if (!$state->shouldMergeScripts() || empty($scripts)) {
+ return;
+ }
+
+ $rootScripts = $root->getScripts();
+ $unwrapped = self::unwrapIfNeeded($root, 'setScripts');
+
+ if ($state->replaceDuplicateLinks()) {
+ $unwrapped->setScripts(
+ array_merge($rootScripts, $scripts)
+ );
+ } else {
+ $unwrapped->setScripts(
+ array_merge($scripts, $rootScripts)
+ );
+ }
+ }
+
+ /**
+ * Merges two arrays either via arrayMergeDeep or via array_merge.
+ *
+ * @param bool $mergeDeep
+ * @param array $array1
+ * @param array $array2
+ * @return array
+ */
+ public static function mergeExtraArray($mergeDeep, $array1, $array2)
+ {
+ if ($mergeDeep) {
+ return NestedArray::mergeDeep($array1, $array2);
+ }
+
+ return array_merge($array1, $array2);
+ }
+
+ /**
+ * Update Links with a 'self.version' constraint with the root package's
+ * version.
+ *
+ * @param string $type Link type
+ * @param array $links
+ * @param RootPackageInterface $root
+ * @return array
+ */
+ protected function replaceSelfVersionDependencies(
+ $type,
+ array $links,
+ RootPackageInterface $root
+ ) {
+ $linkType = BasePackage::$supportedLinkTypes[$type];
+ $version = $root->getVersion();
+ $prettyVersion = $root->getPrettyVersion();
+ $vp = $this->versionParser;
+
+ $method = 'get' . ucfirst($linkType['method']);
+ $packages = $root->$method();
+
+ return array_map(
+ function ($link) use ($linkType, $version, $prettyVersion, $vp, $packages) {
+ if ('self.version' === $link->getPrettyConstraint()) {
+ if (isset($packages[$link->getSource()])) {
+ /** @var Link $package */
+ $package = $packages[$link->getSource()];
+ return new Link(
+ $link->getSource(),
+ $link->getTarget(),
+ $vp->parseConstraints($package->getConstraint()->getPrettyString()),
+ $linkType['description'],
+ $package->getPrettyConstraint()
+ );
+ }
+
+ return new Link(
+ $link->getSource(),
+ $link->getTarget(),
+ $vp->parseConstraints($version),
+ $linkType['description'],
+ $prettyVersion
+ );
+ }
+ return $link;
+ },
+ $links
+ );
+ }
+
+ /**
+ * Get a full featured Package from a RootPackageInterface.
+ *
+ * In Composer versions before 599ad77 the RootPackageInterface only
+ * defines a sub-set of operations needed by composer-merge-plugin and
+ * RootAliasPackage only implemented those methods defined by the
+ * interface. Most of the unimplemented methods in RootAliasPackage can be
+ * worked around because the getter methods that are implemented proxy to
+ * the aliased package which we can modify by unwrapping. The exception
+ * being modifying the 'conflicts', 'provides' and 'replaces' collections.
+ * We have no way to actually modify those collections unfortunately in
+ * older versions of Composer.
+ *
+ * @param RootPackageInterface $root
+ * @param string $method Method needed
+ * @return RootPackageInterface|RootPackage
+ */
+ public static function unwrapIfNeeded(
+ RootPackageInterface $root,
+ $method = 'setExtra'
+ ) {
+ // @codeCoverageIgnoreStart
+ if ($root instanceof RootAliasPackage &&
+ !method_exists($root, $method)
+ ) {
+ // Unwrap and return the aliased RootPackage.
+ $root = $root->getAliasOf();
+ }
+ // @codeCoverageIgnoreEnd
+ return $root;
+ }
+
+ /**
+ * Update the root packages reference information.
+ *
+ * @param RootPackageInterface $root
+ */
+ protected function mergeReferences(RootPackageInterface $root)
+ {
+ // Merge source reference information for merged packages.
+ // @see RootPackageLoader::load
+ $references = array();
+ $unwrapped = $this->unwrapIfNeeded($root, 'setReferences');
+ foreach (array('require', 'require-dev') as $linkType) {
+ $linkInfo = BasePackage::$supportedLinkTypes[$linkType];
+ $method = 'get'.ucfirst($linkInfo['method']);
+ $links = array();
+ foreach ($unwrapped->$method() as $link) {
+ $links[$link->getTarget()] = $link->getConstraint()->getPrettyString();
+ }
+ $references = $this->extractReferences($links, $references);
+ }
+ $unwrapped->setReferences($references);
+ }
+
+ /**
+ * Extract vcs revision from version constraint (dev-master#abc123.
+ *
+ * @param array $requires
+ * @param array $references
+ * @return array
+ * @see RootPackageLoader::extractReferences()
+ */
+ protected function extractReferences(array $requires, array $references)
+ {
+ foreach ($requires as $reqName => $reqVersion) {
+ $reqVersion = preg_replace('{^([^,\s@]+) as .+$}', '$1', $reqVersion);
+ $stabilityName = VersionParser::parseStability($reqVersion);
+ if (
+ preg_match('{^[^,\s@]+?#([a-f0-9]+)$}', $reqVersion, $match) &&
+ $stabilityName === 'dev'
+ ) {
+ $name = strtolower($reqName);
+ $references[$name] = $match[1];
+ }
+ }
+
+ return $references;
+ }
+}
+// vim:sw=4:ts=4:sts=4:et:
scripts.mit.edu / autoinstallsdev / mediawiki.git / blobdiff