Initial commit

Author: pinkeen

.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+/composer.lock

.travis.yml

@@ -0,0 +1,20 @@
+language: php
+sudo: false
+dist: trusty
+
+php:
+  - 5.6
+  - 7.0
+  - 7.1
+  - 7.2
+  - 7.3
+  - nightly
+
+matrix:
+  allow_failures:
+    - php: nightly
+
+install:
+    - travis_retry composer install --ansi --prefer-dist --no-interaction --optimize-autoloader --no-suggest --no-progress
+
+script: ./vendor/bin/phpunit

README.md

@@ -0,0 +1,64 @@
+Composer Plugin For Applying Patchsets
+======================================
+
+This plugin can automatically apply patches to any dependency of your project.
+
+One of the most distinguishing features is that it can apply patches from special composer packages of type `patchset`.
+This is quite convenient as you can store all your patches in one repository and apply them automatically on all
+systems including developer's machines in a very predictable way.
+
+It's (kind-of) an alternative to two other great plugins (differences will become apparent once you read __Features__):
+     
+ * [netresearch/composer-patches-plugin](https://github.com/netresearch/composer-patches-plugin)
+ * [cweagans/composer-patches](https://github.com/cweagans/composer-patches)
+ 
+ 
+## Features
+
+ - Apply patches from dedicated composer packages (package your patchset!).
+ - Each patch can have a version constraint (composer semver) checked against the target package.
+   
+   This means that you can (and should) have the patches fail the build if cannot be applied and still
+   store patches for multiple package versions in the same patchset.
+ - Apply patches using `patch` command and fall-back to `git apply` if not available.
+ - Does not reinstall packages unnecessarily.
+ - Reinstalls (cleans) packages which are patched but the patches have been removed guaranteeing a consistent
+   state after multiple updates.
+ - Will repatch packages even if **order** of patches for specific package (version) has changed.
+ - Deduplicates patches on package level. 
+ - Does not overly tie into composer internals. All patching will be done after the main update/installation
+   process at once execution making it simpler and easier to analyze.
+   
+   This also means that you have the guarantee that the plugin / patches are at the latest version before
+   the process even starts. Otherwise it's very tricky (if not impossible) to make the plugin behave
+   consistently on the first composer install (e.g. no `vendor` dir at all) and the subsequent ones.
+   
+   Double composer update/install for build is not necessary.
+
+### What it cannot do 
+
+ This plugin will not download patches from external sources directly (http). I consider this a bad practice and will
+ never support it. I won't even comment on downloading patches using unencrypted connection without SHA check. Also what
+ if somebody wants to use your software in 2 years and the patches are no longer available?
+ 
+ Also you will not be able to specify patches in any composer package. You have to use a dedicated packages for this 
+ purpose. I can hardly imagine a legit use case when it would be desirable that installing package X will automatically 
+ patch some other package Y in your project without explicitly being advertised as a patchset.
+ 
+### What is missing
+
+ - Patch the root package / files in root directory
+ - Allow to specify patches in the root composer.json
+
+
+
+## Running tests
+
+Just start `vendor/bin/phpunit`.
+If you want to see the output of commands executed during functional testing use the `--debug` switch:
+```
+vendor/bin/phpunit --debug
+```
+
+It's nice to also add the `--testdox` switch then.
+   

composer.json

@@ -0,0 +1,31 @@
+{
+    "name": "creativestyle/composer-plugin-patchset",
+    "description": "Composer plugin that automatically applies patches from a patchset file",
+    "type": "composer-plugin",
+    "license": "OSL-3.0",
+    "authors": [
+        {
+            "name": "Filip Sobalski",
+            "email": "[email protected]"
+        }
+    ],
+    "require": {
+        "ext-json": "*",
+        "php": ">=5.6.0",
+        "composer-plugin-api": "^1.1"
+    },
+    "require-dev": {
+        "composer/composer": "~1.0",
+        "composer/satis": "~1.0",
+        "phpunit/phpunit": "^4.8.35 || ^5.7"
+    },
+    "autoload": {
+        "psr-4": {"Creativestyle\\Composer\\Patchset\\": "src"}
+    },
+    "autoload-dev": {
+        "psr-4": {"Creativestyle\\Composer\\Patchset\\Tests\\": "tests"}
+    },
+    "extra": {
+        "class": "Creativestyle\\Composer\\Patchset\\Plugin"
+    }
+}

phpunit.xml

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xsi:noNamespaceSchemaLocation="https://schema.phpunit.de/5.7/phpunit.xsd"
+        bootstrap="./vendor/autoload.php"
+        backupGlobals="true"
+        cacheTokens="false"
+        colors="true"
+>
+    <filter>
+        <whitelist
+                processUncoveredFilesFromWhitelist="true">
+            <directory suffix=".php">./src</directory>
+        </whitelist>
+    </filter>
+    <testsuites>
+        <testsuite name="Unit">
+            <directory>./tests/Unit</directory>
+        </testsuite>
+        <testsuite name="Functional">
+            <directory>./tests/Functional</directory>
+        </testsuite>
+    </testsuites>
+</phpunit>

src/IOLogger.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Creativestyle\Composer\Patchset;
+
+use Composer\IO\IOInterface;
+use Psr\Log\AbstractLogger;
+use Psr\Log\LogLevel;
+
+class IOLogger extends AbstractLogger
+{
+    const VERBOSITY_LEVEL_MAP = [
+        LogLevel::DEBUG => IOInterface::DEBUG,
+        LogLevel::INFO => IOInterface::NORMAL,
+        LogLevel::NOTICE => IOInterface::QUIET,
+        LogLevel::WARNING => IOInterface::QUIET,
+        LogLevel::ERROR => IOInterface::QUIET,
+        LogLevel::CRITICAL => IOInterface::QUIET,
+        LogLevel::ALERT => IOInterface::QUIET,
+        LogLevel::EMERGENCY => IOInterface::QUIET
+    ];
+
+    const ERROR_LEVELS = [
+        LogLevel::ERROR,
+        LogLevel::CRITICAL,
+        LogLevel::ALERT,
+        LogLevel::EMERGENCY,
+    ];
+
+    /**
+     * @var IOInterface
+     */
+    private $io;
+
+    /**
+     * @param IOInterface $io
+     */
+    public function __construct(IOInterface $io)
+    {
+        $this->io = $io;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function log($level, $message, array $context = array())
+    {
+        $verbosity = self::VERBOSITY_LEVEL_MAP[$level];
+
+        if (in_array($level, self::ERROR_LEVELS)) {
+            $this->io->writeError($message, true, $verbosity);
+        } else {
+            $this->io->write($message, true, $verbosity);
+        }
+    }
+}

src/OperationResolver.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Creativestyle\Composer\Patchset;
+
+use Composer\DependencyResolver\Operation\InstallOperation;
+use Composer\DependencyResolver\Operation\UninstallOperation;
+use Composer\DependencyResolver\Operation\UpdateOperation;
+
+use Composer\Installer\NoopInstaller;
+use Composer\Repository\InstalledArrayRepository;
+use Composer\Repository\RepositoryInterface;
+
+class OperationResolver
+{
+    /**
+     * Returns a repository that reflects the state after operations have been executed on the current one.
+     *
+     * @param RepositoryInterface $repository
+     * @param array $operations
+     * @return RepositoryInterface
+     */
+    public function resolveState(RepositoryInterface $repository, array $operations)
+    {
+        $packages = array_map(function($p) { return clone $p; }, $repository->getPackages());
+        $installed = new InstalledArrayRepository($packages);
+        $installer = new NoopInstaller();
+
+        foreach ($operations as $operation) {
+            if ($operation instanceof InstallOperation) {
+                $installer->install($installed, $operation->getPackage());
+            } elseif ($operation instanceof UpdateOperation) {
+                $installer->update($installed, $operation->getInitialPackage(), $operation->getTargetPackage());
+            } elseif ($operation instanceof UninstallOperation) {
+                $installer->uninstall($installed, $operation->getPackage());
+            }
+        }
+
+        return $installed;
+    }
+}