Merge pull request #547 from cweagans/dependency-patches

Dependency patch resolution

Author: cweagans

docs/api/patches-lock-json.md

@@ -19,4 +19,4 @@ If the [`COMPOSER`]({{< relref "../usage/configuration.md#composer" >}}) environ
 ```
 * Each patch definition will look like the [expanded format]({{< relref "../usage/defining-patches.md#expanded-format" >}}) that users can put into their `composer.json` or external patches file.
 * No _removals_ or _changes_ will be made to the patch definition object. _Additional_ keys may be created, so any JSON parsing you're doing should be tolerant of new keys.
-* The `extra` object in each patch definition may contain a number of attributes set by other projects or by the user and should be treated as free-form input.
+* The `extra` object in each patch definition may contain a number of attributes set by other projects or by the user and should be treated as free-form input. Currently, Composer Patches uses this attribute to store information about where a patch was defined (in the `provenance` key).

docs/usage/configuration.md

@@ -49,6 +49,27 @@ Technically, this value can be a path to a file that is nested in a deeper direc
 
 ---
 
+### `ignore-dependency-patches`
+
+```json
+{
+    [...],
+    "extra": {
+        "composer-patches": {
+            "ignore-dependency-patches": [
+                "some/package",
+            ]
+        }
+    }
+}
+```
+
+**Default value**: empty
+
+`ignore-dependency-patches` allows you to ignore patches defined by the listed dependencies. For instance, if your project requires `drupal/core` and `some/package`, and `some/package` defines a patch for `drupal/core`, listing `some/package` in `ignore-dependency-patches` would cause that patch to be ignored. This does _not_ affect the _target_ of those patches. For instance, listing `drupal/core` here would not cause patches _to_ `drupal/core` to be ignored.
+
+---
+
 ### `default-patch-depth`
 
 ```json
@@ -81,7 +102,8 @@ You probably don't need to change this value. Instead, consider setting a packag
         "composer-patches": {
             "disable-resolvers": [
                 "\\cweagans\\Composer\\Resolver\\RootComposer",
-                "\\cweagans\\Composer\\Resolver\\PatchesFile"
+                "\\cweagans\\Composer\\Resolver\\PatchesFile",
+                "\\cweagans\\Composer\\Resolver\\Dependencies"
             ]
         }
     }

docs/usage/defining-patches.md

@@ -130,6 +130,15 @@ If you're defining patches in `patches.json` (or some other separate patches fil
 }
 ```
 
+### Dependencies
+
+Packages required by your project can define patches as well. They can do so by defining patches in their root `composer.json` file. Defining patches in a separate `patches.json` in a dependency is currently unsupported.
+
+{{< callout title="Patch paths are always relative to the root of your project" >}}
+Patches defined by a dependency should always use a publicly accessible URL, rather than a local file path. Composer Patches _will not_ attempt to modify file paths so that the patch file can be found within the installed location of a dependency.
+{{< /callout >}}
+
+
 ## Duplicate patches
 
 If the same patch is defined in multiple places, the first one added to the patch collection "wins". Subsequent definitions of the same patch will be ignored without emitting an error. The criteria used for determining whether two patches are the same are:

src/Capability/Resolver/CoreResolverProvider.php

@@ -16,6 +16,7 @@ public function getResolvers(): array
         return [
             new RootComposer($this->composer, $this->io, $this->plugin),
             new PatchesFile($this->composer, $this->io, $this->plugin),
+            new Dependencies($this->composer, $this->io, $this->plugin),
         ];
     }
 }

src/Downloader.php

@@ -52,9 +52,10 @@ public function downloadPatch(Patch $patch)
         }
 
         foreach ($this->getDownloaders() as $downloader) {
-            if (in_array(get_class($downloader), $this->disabledDownloaders, true)) {
+            $class = "\\" . get_class($downloader);
+            if (in_array($class, $this->disabledDownloaders, true)) {
                 $this->io->write(
-                    '<info>  - Skipping downloader ' . get_class($downloader) . '</info>',
+                    '<info>  - Skipping downloader ' . $class . '</info>',
                     true,
                     IOInterface::VERBOSE
                 );

src/Patch.php

@@ -50,7 +50,7 @@ class Patch implements JsonSerializable
     public ?string $localPath;
 
     /**
-     * This is unused in the main plugin, but can be used as a place for other plugins to store data about a patch.
+     * Can be used as a place for other plugins to store data about a patch.
      *
      * This should be treated as an associative array and should contain only scalar values.
      *

src/Patcher.php

@@ -41,9 +41,10 @@ public function __construct(Composer $composer, IOInterface $io, array $disabled
     public function applyPatch(Patch $patch, string $path): bool
     {
         foreach ($this->getPatchers() as $patcher) {
-            if (in_array(get_class($patcher), $this->disabledPatchers, true)) {
+            $class = "\\" . get_class($patcher);
+            if (in_array($class, $this->disabledPatchers, true)) {
                 $this->io->write(
-                    '<info>  - Skipping patcher ' . get_class($patcher) . '</info>',
+                    '<info>  - Skipping patcher ' . $class . '</info>',
                     true,
                     IOInterface::VERBOSE
                 );

src/Plugin/Patches.php

@@ -145,7 +145,11 @@ public function activate(Composer $composer, IOInterface $io): void
             'patches-file' => [
                 'type' => 'string',
                 'default' => 'patches.json',
-            ]
+            ],
+            "ignore-dependency-patches" => [
+                'type' => 'list',
+                'default' => [],
+            ],
         ];
         $this->configure($this->composer->getPackage()->getExtra(), 'composer-patches');
     }

src/Resolver.php

@@ -45,9 +45,11 @@ public function loadFromResolvers(): PatchCollection
         // Let each resolver discover patches and add them to the PatchCollection.
         /** @var ResolverInterface $resolver */
         foreach ($this->getPatchResolvers() as $resolver) {
-            if (in_array(get_class($resolver), $this->disabledResolvers, true)) {
+            $class = "\\" . get_class($resolver);
+
+            if (in_array($class, $this->disabledResolvers, true)) {
                 $this->io->write(
-                    '<info>  - Skipping resolver ' . get_class($resolver) . '</info>',
+                    '<info>  - Skipping resolver ' . $class . '</info>',
                     true,
                     IOInterface::VERBOSE
                 );

src/Resolver/Dependencies.php

@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * @file
+ * Contains \cweagans\Composer\Resolvers\Dependencies.
+ */
+
+namespace cweagans\Composer\Resolver;
+
+use cweagans\Composer\Patch;
+use cweagans\Composer\PatchCollection;
+
+class Dependencies extends ResolverBase
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function resolve(PatchCollection $collection): void
+    {
+        $locker = $this->composer->getLocker();
+        if (!$locker->isLocked()) {
+            $this->io->write('  - <info>Composer lock file does not exist.</info>');
+            $this->io->write('  - <info>Patches defined in dependencies will not be resolved.</info>');
+            return;
+        }
+
+        $this->io->write('  - <info>Resolving patches from dependencies.</info>');
+
+        $ignored_dependencies = $this->plugin->getConfig('ignore-dependency-patches');
+
+        $lockdata = $locker->getLockData();
+        foreach ($lockdata['packages'] as $p) {
+            // If we're supposed to skip gathering patches from a dependency, do that.
+            if (in_array($p['name'], $ignored_dependencies)) {
+                continue;
+            }
+
+            // Find patches in the composer.json for dependencies.
+            if (!isset($p['extra']) || !isset($p['extra']['patches'])) {
+                continue;
+            }
+            foreach ($this->findPatchesInJson($p['extra']['patches']) as $package => $patches) {
+                foreach ($patches as $patch) {
+                    $patch->extra['provenance'] = "dependency:" . $package;
+
+                    /** @var Patch $patch */
+                    $collection->addPatch($patch);
+                }
+            }
+
+            // TODO: Also find patches in a configured patches.json for the dependency.
+        }
+    }
+}