Merge one or more additional composer.json files at Composer runtime

Last update: May 16, 2022

Latest Stable Version License Build Status Code Coverage

Composer Merge Plugin

Merge multiple composer.json files at Composer runtime.

Composer Merge Plugin is intended to allow easier dependency management for applications which ship a composer.json file and expect some deployments to install additional Composer managed libraries. It does this by allowing the application's top level composer.json file to provide a list of optional additional configuration files. When Composer is run it will parse these files and merge their configuration settings into the base configuration. This combined configuration will then be used when downloading additional libraries and generating the autoloader.

Composer Merge Plugin was created to help with installation of MediaWiki which has core library requirements as well as optional libraries and extensions which may be managed via Composer.

Installation

Composer Merge Plugin 1.4.x (and older) requires Composer 1.x.

Composer Merge Plugin 2.0.x (and newer) is compatible with both Composer 2.x and 1.x.

$ composer require wikimedia/composer-merge-plugin

Upgrading from Composer 1 to 2

If you are already using Composer Merge Plugin 1.4 (or older) and you are updating the plugin to 2.0 (or newer), it is recommended that you update the plugin first using Composer 1.

If you update the incompatible plugin using Composer 2, the plugin will be ignored:

The "wikimedia/composer-merge-plugin" plugin was skipped because it requires a Plugin API version ("^1.0") that does not match your Composer installation ("2.0.0"). You may need to run composer update with the "--no-plugins" option.

Consequently, Composer will be unaware of the merged dependencies and will remove them requiring you to run composer update again to reinstall merged dependencies.

Usage

{
    "require": {
        "wikimedia/composer-merge-plugin": "dev-master"
    },
    "extra": {
        "merge-plugin": {
            "include": [
                "composer.local.json",
                "extensions/*/composer.json"
            ],
            "require": [
                "submodule/composer.json"
            ],
            "recurse": true,
            "replace": false,
            "ignore-duplicates": false,
            "merge-dev": true,
            "merge-extra": false,
            "merge-extra-deep": false,
            "merge-scripts": false
        }
    }
}

Updating sub-levels composer.json files

In order for Composer Merge Plugin to install dependencies from updated or newly created sub-level composer.json files in your project you need to run the command:

$ composer update

This will instruct Composer to recalculate the file hash for the top-level composer.json thus triggering Composer Merge Plugin to look for the sub-level configuration files and update your dependencies.

Plugin configuration

The plugin reads its configuration from the merge-plugin section of your composer.json's extra section. An include setting is required to tell Composer Merge Plugin which file(s) to merge.

include

The include setting can specify either a single value or an array of values. Each value is treated as a PHP glob() pattern identifying additional composer.json style configuration files to merge into the root package configuration for the current Composer execution.

The following sections of the found configuration files will be merged into the Composer root package configuration as though they were directly included in the top-level composer.json file:

require

The require setting is identical to include except when a pattern fails to match at least one file then it will cause an error.

recurse

By default the merge plugin is recursive; if an included file has a merge-plugin section it will also be processed. This functionality can be disabled by adding a "recurse": false setting.

replace

By default, Composer's conflict resolution engine is used to determine which version of a package should be installed when multiple files specify the same package. A "replace": true setting can be provided to change to a "last version specified wins" conflict resolution strategy. In this mode, duplicate package declarations found in merged files will overwrite the declarations made by earlier files. Files are loaded in the order specified by the include setting with globbed files being processed in alphabetical order.

ignore-duplicates

By default, Composer's conflict resolution engine is used to determine which version of a package should be installed when multiple files specify the same package. An "ignore-duplicates": true setting can be provided to change to a "first version specified wins" conflict resolution strategy. In this mode, duplicate package declarations found in merged files will be ignored in favor of the declarations made by earlier files. Files are loaded in the order specified by the include setting with globbed files being processed in alphabetical order.

Note: "replace": true and "ignore-duplicates": true modes are mutually exclusive. If both are set, "ignore-duplicates": true will be used.

merge-dev

By default, autoload-dev and require-dev sections of included files are merged. A "merge-dev": false setting will disable this behavior.

merge-extra

A "merge-extra": true setting enables the merging the contents of the extra section of included files as well. The normal merge mode for the extra section is to accept the first version of any key found (e.g. a key in the master config wins over the version found in any imported config). If replace mode is active (see above) then this behavior changes and the last key found will win (e.g. the key in the master config is replaced by the key in the imported config). If "merge-extra-deep": true is specified then, the sections are merged similar to array_merge_recursive() - however duplicate string array keys are replaced instead of merged, while numeric array keys are merged as usual. The usefulness of merging the extra section will vary depending on the Composer plugins being used and the order in which they are processed by Composer.

Note that merge-plugin sections are excluded from the merge process, but are always processed by the plugin unless recursion is disabled.

merge-scripts

A "merge-scripts": true setting enables merging the contents of the scripts section of included files as well. The normal merge mode for the scripts section is to accept the first version of any key found (e.g. a key in the master config wins over the version found in any imported config). If replace mode is active (see above) then this behavior changes and the last key found will win (e.g. the key in the master config is replaced by the key in the imported config).

Note: custom commands added by merged configuration will work when invoked as composer run-script my-cool-command but will not be available using the normal composer my-cool-command shortcut.

Running tests

$ composer install
$ composer test

Contributing

Bug, feature requests and other issues should be reported to the GitHub project. We accept code and documentation contributions via Pull Requests on GitHub as well.

  • PSR-2 Coding Standard is used by the project. The included test configuration uses PHP Code Sniffer to validate the conventions.
  • Tests are encouraged. Our test coverage isn't perfect but we'd like it to get better rather than worse, so please try to include tests with your changes.
  • Keep the documentation up to date. Make sure README.md and other relevant documentation is kept up to date with your changes.
  • One pull request per feature. Try to keep your changes focused on solving a single problem. This will make it easier for us to review the change and easier for you to make sure you have updated the necessary tests and documentation.

License

Composer Merge plugin is licensed under the MIT license. See the LICENSE file for more details.


GitHub

https://github.com/wikimedia/composer-merge-plugin
Comments
  • 1. Add support for Composer v2

    Latest Update 2021-01-25 14:25 EST

    Notes:

    1. Avoid unnecessary issue bumping. Please test this pull request and report issues or approve working state.
      See comment.
    2. Stability of this pull request's changeset needs additional testing from the community, such as unintentional updates upon requiring this plugin.
      See comment.
    3. Project is stuck in the process of transferring ownership to a new team within the Wikimedia Foundation.
      See comment.
    4. Since v1.4 of the plugin does not support Composer v2, the plugin is ignored when updating to v1.5. As a result, Composer is unaware of the merged dependencies and removes them. Either update the plugin with Composer v1 first or run composer update again.
      See comment.
    5. Unintentional lock file updates caused by isFirstInstall() on Composer v2. Listening only to post-update-cmd instead of post-install-cmd might be more sensible. See comment and followup.
    6. Please be patient, we don't want to push broken changes.

    How to test:

    {
        "repositories": [
            {
                "type":"vcs",
                "url":"https://github.com/mcaskill/composer-merge-plugin"
            }
        ],
        "require": {
            "wikimedia/composer-merge-plugin": "dev-feature/composer-v2 as 1.5.0"
        }
    }
    

    Tasks:

    • [x] Find alternative to install inherited dependencies without affecting locked dependencies.
      See comment #1, comment #2, comment #3.
    • [x] Rebase to include #197 and #199
    • [x] Update port of MultiConstraint to latest version of composer/semver.
      See comment.
    • [x] Method Factory::getLockFile() does not exist in Composer 1.
      See comment.

    Replaces #187, #185, as fix for #184 (as per composer/composer#8726)

    I've tested using the example and the unit tests and it works in Composer v1 and v2.

    This alternative proposal forgoes PRE_DEPENDENCIES_SOLVING entirely to avoid over-complicating the codebase and streamline the plugin's merge logic.

    The issue with the previous attempts (as well as attempts on other plugins) stems from a miscommunication from the Composer team of the major difference in how v1 and v2 resolve and install dependencies.

    […] Roughly speaking:

    • Composer v1: Composer resolves dependencies (dispatching *_DEPENDENCIES_SOLVING), iterates packages (while dispatching PRE_PACKAGE_* before PRE_FILE_DOWNLOAD), then finally writes the lock file.
    • Composer v2: Composer resolves dependencies (dispatching PRE_POOL_CREATE), writes the lock file, dispatches PRE_OPERATIONS_EXEC, downloads the packages (while dispatching PRE_FILE_DOWNLOAD), then iterates packages (while dispatching PRE_PACKAGE_*).

    In particular, people are assuming that PRE_OPERATIONS_EXEC is a replacement for PRE_DEPENDENCIES_SOLVING since they are dispatched in a similar-looking routine. The closest event to the latter would actually be PRE_POOL_CREATE. — composer/composer#8726

    Back to my proposal.

    Currently, the use of PRE_DEPENDENCIES_SOLVING in the plugin is used to inject duplicate requirements (usually with a different version constraints) into the solver (while distinguishing between require and require-dev).

    What I propose replaces the duplicate links tracking in ExtraPackage by back porting Composer 2's new static MultiConstraint::create() method which can be used to resolve complex-constraints early on. In turn, this makes the need for PRE_DEPENDENCIES_SOLVING obsolete.

    I hope this PR will, at the very least, help to figure out how to support Composer v2.

    Reviewed by mcaskill at 2020-09-28 15:49
  • 2. Compatibilty with Composer 2.0

    If you've landed here looking for a version of the wikimedia/composer-merge-plugin compatible with Composer 2.0, please see https://github.com/wikimedia/composer-merge-plugin/pull/189 and help test!


    It seems like composer 2.0 is right around the corner. Downloading https://getcomposer.org/composer.phar already gives you a 2.0 build.

    Are there any plans to make this plugin compatible? It currently explicitly requires a v1 composer api to be present.

    Your requirements could not be resolved to an installable set of packages.
    
      Problem 1
        - Root composer.json requires wikimedia/composer-merge-plugin 1.4.1 -> satisfiable by wikimedia/composer-merge-plugin[v1.4.1].
        - wikimedia/composer-merge-plugin v1.4.1 requires composer-plugin-api ^1.0 -> found composer-plugin-api[2.0.0] but it does not match your constraint.
    
    Reviewed by tobias-kuendig at 2020-04-08 08:39
  • 3. [FR] Add merge `autoload` and resolve paths

    It would be great if this addon also supported merging of PSR-4 autoload classes:

    "autoload": {
        "psr-4": {
            "Boardworld\\": "app/third_party/boardworld/src/"
        }
    }
    

    Additionally relative paths in included composer files should have their paths resolved correctly.

    Reviewed by leevigraham at 2015-03-24 02:46
  • 4. Add ability to merge remote composer configurations via http

    I needed to pull a centralized list of required packages into multiple composer configs. Since composer has the ability to read JSON contents from a remote source via HTTP it was a straight forward change to composer-merge-plugin to correctly validate that the url exists (but still use glob for local files) and pass a RemoteFileSystem object to JsonFile constructor if we're dealing with a URL.

    Reviewed by codeandcountry at 2015-12-16 20:55
  • 5. exists successfully after only half the work done

    Running composer with the merge plugin just exits successfully (return 0) with only half the work done. I need to run it a second time to finish the work.

    Example: https://integration.wikimedia.org/ci/job/mwext-WikidataQuality-repo-tests-mysql-hhvm/164/consoleFull (search for composer update and see were on the second invocation it still has more work to do).

    Reviewed by JanZerebecki at 2015-06-17 20:06
  • 6. allow modern PHPUnit

     $ vendor/bin/phpunit --verbose
     PHPUnit 5.0.5 by Sebastian Bergmann and contributors.
    
     Runtime:       PHP 5.6.14 with Xdebug 2.3.3
     Configuration: /work/GIT/composer-merge-plugin/phpunit.xml.dist
    
     ......................                                            22 / 22 (100%)
    
     Time: 232 ms, Memory: 17.75Mb
    
     OK (22 tests, 223 assertions)
    
    Reviewed by remicollet at 2015-10-12 07:51
  • 7. Allow merging of extra section in a deep way.

    Motivation

    I am trying to use composer-merge-plugin with a composer-patches variation, which is late enough for composer-merge-plugin to have merged all sections.

    My root composer.json has something like:

    {
        "extra": {
            "merge-plugin": {
                "merge-extra": true,
                "merge-deep": true,
                "include": "composer.local.json"
            },
            "patches": {
                "wikimedia/composer-merge-plugin": {
                    "Add tests for merge-deep option": "patches/add-tests-for-merge-deep-option.diff"
                },
                "anothervendor/some-project": {
                    "some-patch": "patches/some-patch.diff"
                }
            }
        }
    }
    

    while my composer.local.json has:

    {
        "extra": {
            "patches": {
                "wikimedia/composer-merge-plugin": {
                    "Allow merging of sections in a deep way": "patches/add-merge-deep-option.diff"
                },
                "somevendor/some-project": {
                    "some-patch": "patches/some-patch.diff"
                }
            }
        }
    }
    

    Approach

    This adds a merge-deep option, which only really is meaningful for the extra sections using an utility function from Drupal.

    This makes the merge plugin much more useful for plugins that have deeper structures.

    This also allows both kinda workflows that the merge plugin is used with:

    • Defining some base skeleton files and including that, then overriding some keys (replace = TRUE)
    • Overriding the global composer.json with a local variant.

    Hopefully no-one will need this together, because that use case is not yet 'done', however I feel this is complex enough as is, to be a follow-up discussion.

    Notes

    Unfortunately Drupal 8 at the moment does not allow to reference the NestedArray component directly via a subtree split, so I had to copy the code for now.

    • Also see:
    • https://github.com/composer/composer/issues/5232 - where I am suggesting to give composer-merge-plugin a chance to always be run after init.
    • https://github.com/douggreen/drupal-composer-installer/pull/9 - where I am using this functionality.
    Reviewed by LionsAd at 2016-04-22 08:54
  • 8. Merging VCS repository override of published package fails

    First reported by @ghprod in https://github.com/wikimedia/composer-merge-plugin/issues/71#issuecomment-154435583

    composer.json:

    {
        "require": {
            "wikimedia/composer-merge-plugin": "dev-master"
        },
        "config": {
            "preferred-install": "dist"
        },
        "extra": {
            "merge-plugin": {
                "include": "composer.local.json"
            }
        }
    }
    

    composer.local.json:

    {
        "repositories": [
            {
                "type": "vcs",
                "url": "https://github.com/ghprod/laravel-menu"
            }
        ],
        "require":{
            "lavary/laravel-menu": "dev-master#956e50f"
        }
    }
    

    Result:

    $ composer -vvv update
    [...snip...]
    Loading plugin Wikimedia\Composer\MergePlugin
      [merge-plugin] Loading composer.local.json...
      [merge-plugin] Adding vcs repository github.com/ghprod/laravel-menu
      [merge-plugin] Merging lavary/laravel-menu
    Loading composer repositories with package information
    [...snip...]
    Downloading https://api.github.com/repos/ghprod/laravel-menu
    Downloading https://api.github.com/repos/ghprod/laravel-menu/contents/composer.json?ref=master
    Downloading https://api.github.com/repos/ghprod/laravel-menu/commits/master
    Downloading https://api.github.com/repos/ghprod/laravel-menu/tags?per_page=100
    Downloading https://api.github.com/repos/ghprod/laravel-menu/git/refs/heads?per_page=100
    [...snip...]
    Reading composer.json of lavary/laravel-menu (master)
    Downloading https://api.github.com/repos/ghprod/laravel-menu/contents/composer.json?ref=956e50fbf0d99b2804539069b012ad52b4851dd2
    Downloading https://api.github.com/repos/ghprod/laravel-menu/commits/956e50fbf0d99b2804539069b012ad52b4851dd2
    [...snip...]
    Downloading http://packagist.org/p/lavary/laravel-menu%24cb8432bd74b707af0300352a1d49742389810f45e5646550e5dca3a823fe4c55.json
    [...snip...]
    Analyzed 1426 packages to resolve dependencies
    Analyzed 1200 rules to resolve dependencies
    [...snip...]
      - Installing lavary/laravel-menu (dev-master bebce99)
    Downloading https://api.github.com/repos/lavary/laravel-menu/zipball/bebce996ef08cf911da0139c30a2da03a2768326
    

    The installed revision (bebce99) is the head of the dev branch of the project as listed on Packagist. The alternate VCS repository was not used.

    If the require for "lavary/laravel-menu" is moved to composer.json, results are slightly different but still not correct. In that case the logs report:

      - Installing lavary/laravel-menu (dev-master 956e50f)
    Downloading https://api.github.com/repos/lavary/laravel-menu/zipball/956e50f
    

    This download is still from the wrong repository in this case and the files fetched from GitHub are not not actually for the desired hash.

    If the "repositories" are moved to composer.json instead, the new output is:

      - Installing lavary/laravel-menu (dev-master 956e50f)
    Downloading https://api.github.com/repos/ghprod/laravel-menu/zipball/956e50fbf0d99b2804539069b012ad52b4851dd2
    

    This is the desired result for all three tests.

    I think the issue here is the order that the repositories are added to Composer\Repository\RepositoryManager. It may take an upstream patch to fix this properly.

    Reviewed by bd808 at 2015-11-09 05:53
  • 9. Merged VCS repositories aren't installed

    I've got a project with a main composer.json and a merged composer.json which I'm trying to use to install a private git project.

    With the repository and require config in the merged JSON file the project isn't installed with composer giving a 'package ... could not be found in any version' error.

    Moving the repository and require to the main composer.json files results in the package being installed.

    A package which is listed on packagist (doesn't require a repository entry in the composer config) installs ok from the merged file.

    The installed composer-merge-plugin is at 361e098955069062c2d688a2c116d7dd837acb38

    Reviewed by robbytaylor at 2015-09-11 14:50
  • 10. Drupal 8.2.7 to 8.3.0 update vender conflicts

    I am using composer-merge-plugin and trying to update from 8.2.7 to 8.3.0 using the following process

    • Update composer.json with the new version of drupal
    • Run the following command composer update drupal/core --with-dependencies

    I am receiving the following error.

    Your requirements could not be resolved to an installable set of packages. Problem 1 - Can only install one of: symfony/psr-http-message-bridge[1.0.x-dev, v0.2]. - Can only install one of: symfony/psr-http-message-bridge[v0.2, 1.0.x-dev]. - Can only install one of: symfony/psr-http-message-bridge[1.0.x-dev, v0.2]. - drupal/core 8.3.0 requires symfony/psr-http-message-bridge ^1.0 -> satisfiable by symfony/psr-http-message-bridge[1.0.x-dev]. - Installation request for drupal/core 8.3.0 -> satisfiable by drupal/core[8.3.0]. - Installation request for symfony/psr-http-message-bridge v0.2 -> satisfiable by symfony/psr-http-message-bridge[v0.2].

    It seems like composer is looking at my current lock file (with version 0.2 for psr-http-message-bridge) instead of the merged version from the core/composer.json in drupal core.

    I am not sure how this plugin works with lock files after looking through it a bit and was wondering if anyone could provide some insight if this is a higher composer issue or a merge-plugin issue

    Reviewed by Aeotrin at 2017-04-07 15:31
  • 11. Add ability to execute post-install/post-update command event handlers from included files

    Is there any way to execute scripts from composer.local.json? I trying to allow custom sites to add additional themes and ensure that theme is activated after install or update. Perhaps with an option to append or override scripts from the parent composer.json file?

    Reviewed by jjtroberts at 2016-08-17 18:44
  • 12. Rewrite relative paths in other parts of composer.json?

    Hi there. I'm trying to add patches (applied via cweagans/composer-patches) to Drupal modules that I develop that are defined in their own composer.json files which are merged into the root composer.json, but the merge plug-in isn't aware of those paths - is there some way to configure the plug-in to apply the relative path rewriting to additional parts of the composer.json in such cases?

    Reviewed by Ambient-Impact at 2022-03-28 17:50
  • 13. Merge in `config` / `allow-plugins`

    Right now, suppose there is a root composer.json with the following peroperties set:

    {
      "config": {
        "allow-plugins": {
          "some-plugin": true
        }
      },
      "extra": {
          "merge-plugin": {
              "include": [
                  "composer.local.json"
              ],
              "recurse": true,
              "replace": false,
              "ignore-duplicates": false,
              "merge-dev": true,
              "merge-extra": false,
              "merge-extra-deep": false,
              "merge-scripts": false
          }
      }
    }
    

    (simplified)

    and the following composer.local.json:

    {
      "require": {
        "composer/installers": ">=1.0.1"
      },
      "config": {
        "allow-plugins": {
          "some-plugin": true
        }
      }
    }
    

    Running composer update with this setup will try to install the composer/installers plugin. However, as it is not mentioned in the main allow-plugins section, the user will be prompted to decide if this plugin is allowed to be installed or not.

    The composer-merge plugin should merge in the allow-plugins config from included into the main one. However, I'm not quite sure on what level: Should it be only the allow-plugins property, which probably would be fine to do unconditionally. If it would make sense to consider the whole config property, it would most likely make sense to have a merge-config (or alike) config for the merge-plugin, like it is already present for the extra and scripts properties.

    Reviewed by FlorianSW at 2022-02-25 12:45
  • 14. Merged packages are not updated by Dependabot and are actually removed

    Hello

    We've discovered that dependabot is not aware of the merged requirements or repositories added by composer-merge-plugin. This is intentional as dependabot does not run plugin scripts and likely never will. So in a way the two are not compatible.

    Worst still, however, is that Dependabot's composer update will then not know about the requirements and strip them from the resulting lock file. This is intentional. As far as composer is concerned the new updated package meant these packages were no longer needed and so are removed since there is no longer a requirement for them anywhere (scripts didn't run.)

    I think the way to resolve this potentially is for merge plugin to actually write the merged repository and requirements to the composer JSON file. Could this be a valid feature request?

    It has two advantages:

    1. Currently when you merge a composer JSON and commit - in a code review you would never see what is merged. So any new repository definitions that get added will not be reviewable. By merging into composer.json directly you would see these. This enhances the security as at the moment if you merge in a composer JSON and it gets updated you'd never know what changes happened and it could add spurious repository definitions.
    2. When Dependabot or other tools run without scripts - it wouldn't matter - all requirements and repositories are in the composer JSON file.

    For now we're doing the merge manually into composer JSON as it gives both benefits.

    Reviewed by driskell at 2022-01-31 13:10
  • 15. Composer v2 upgrading Composer Merge Plugin 1.4 (or older)

    The readme says:

    If you are already using Composer Merge Plugin 1.4 (or older) and you are updating the plugin to 2.0 (or newer), it is recommended that you update the plugin first using Composer 1.

    What is the procedure if we are already using Composer 2 and cannot downgrade?

    Reviewed by audouts at 2022-01-20 01:46
  • 16. Error With Composer [email protected]

    Symptoms

    When used on GitHub Actions, the following error is produced:

    Running composer update to apply merge settings
    Loading composer repositories with package information
    
    PHP Fatal error:  Uncaught TypeError: Cannot access offset of type string on string in phar:///usr/local/bin/composer/src/Composer/Util/HttpDownloader.php:484
    Stack trace:
    #0 phar:///usr/local/bin/composer/src/Composer/Util/Http/CurlDownloader.php(399): Composer\Util\HttpDownloader::outputWarnings()
    #1 phar:///usr/local/bin/composer/src/Composer/Util/HttpDownloader.php(404): Composer\Util\Http\CurlDownloader->tick()
    #2 phar:///usr/local/bin/composer/src/Composer/Util/Loop.php(96): Composer\Util\HttpDownloader->countActiveJobs()
    #3 phar:///usr/local/bin/composer/src/Composer/Repository/ComposerRepository.php(957): Composer\Util\Loop->wait()
    #4 phar:///usr/local/bin/composer/src/Composer/Repository/ComposerRepository.php(524): Composer\Repository\ComposerRepository->loadAsyncPackages()
    #5 phar:///usr/local/bin/composer/src/Composer/DependencyResolver/PoolBuilder.php(379): Composer\Repository\ComposerRepository->loadPackages()
    #6 phar:///usr/local/bin/composer/src/Composer/DependencyResolver/PoolBuilder.php(234): Composer\DependencyResolver\PoolBuilder->loadPackagesMarkedForLoading()
    #7 phar:///usr/local/bin/composer/src/Composer/Repository/RepositorySet.php(261): Composer\DependencyResolver\PoolBuilder->buildPool()
    #8 phar:///usr/local/bin/composer/src/Composer/Installer.php(435): Composer\Repository\RepositorySet->createPool()
    #9 phar:///usr/local/bin/composer/src/Composer/Installer.php(279): Composer\Installer->doUpdate()
    #10 /home/runner/work/payoneer-for-woocommerce/payoneer-for-woocommerce/vendor/wikimedia/composer-merge-plugin/src/MergePlugin.php(377): Composer\Installer->run()
    #11 [internal function]: Wikimedia\Composer\Merge\V2\MergePlugin->onPostInstallOrUpdate()
    #12 phar:///usr/local/bin/composer/src/Composer/EventDispatcher/EventDispatcher.php(192): call_user_func()
    #13 phar:///usr/local/bin/composer/src/Composer/EventDispatcher/EventDispatcher.php(119): Composer\EventDispatcher\EventDispatcher->doDispatch()
    #14 phar:///usr/local/bin/composer/src/Composer/Installer.php(372): Composer\EventDispatcher\EventDispatcher->dispatchScript()
    #15 phar:///usr/local/bin/composer/src/Composer/Command/InstallCommand.php(139): Composer\Installer->run()
    #16 phar:///usr/local/bin/composer/vendor/symfony/console/Command/Command.php(245): Composer\Command\InstallCommand->execute()
    #17 phar:///usr/local/bin/composer/vendor/symfony/console/Application.php(835): Symfony\Component\Console\Command\Command->run()
    #18 phar:///usr/local/bin/composer/vendor/symfony/console/Application.php(185): Symfony\Component\Console\Application->doRunCommand()
    #19 phar:///usr/local/bin/composer/src/Composer/Console/Application.php(335): Symfony\Component\Console\Application->doRun()
    #20 phar:///usr/local/bin/composer/vendor/symfony/console/Application.php(117): Composer\Console\Application->doRun()
    #21 phar:///usr/local/bin/composer/src/Composer/Console/Application.php(130): Symfony\Component\Console\Application->run()
    #22 phar:///usr/local/bin/composer/bin/composer(73): Composer\Console\Application->run()
    #23 /usr/local/bin/composer(29): require('...')
    #24 {main}
      thrown in phar:///usr/local/bin/composer/src/Composer/Util/HttpDownloader.php on line 484
    

    Reproducing

    • PHP: 7.4, 8.0;
    • Package: v2.0.1.
    • Composer: 2.2.1. ⚠️ Cannot reproduce on 2.1.14.
    Reviewed by XedinUnknown at 2021-12-23 05:43
Check your Composer dependencies at runtime.

Composition Composition provides a lightweight and generic API, that you can use to check your environment at runtime, instead of manually go checking

May 4, 2021
Easily parse your project's Composer configuration, and those of its dependencies, at runtime

Composed This library provides a set of utility functions designed to help you parse your project's Composer configuration, and those of its dependenc

Apr 11, 2021
:musical_note: Provides a composer plugin for normalizing composer.json.
:musical_note: Provides a composer plugin for normalizing composer.json.

composer-normalize Provides a composer plugin for normalizing composer.json. Why When it comes to formatting composer.json, you have the following opt

May 28, 2022
Simple static Composer repository generator - For a full private Composer repo use Private Packagist

Satis Simple static Composer repository generator. Run from source Satis requires a recent PHP version, it does not run with unsupported PHP versions.

May 25, 2022
composer parallel install plugin
composer parallel install plugin

prestissimo (composer plugin) This is a composer 1.x plugin that downloads packages in parallel to speed up the installation process. Announcement: Co

May 20, 2022
Patch other composer packages on install or update

patch-installer Patch other composer packages on install or update. experimental feature Usage For a patch type change the install path to vendor dire

Apr 11, 2021
A no-frills PsySH-Composer plugin
A no-frills PsySH-Composer plugin

uma/composer-psysh A no-frills PsySH-Composer plugin. In a nutshell, it provides a composer psy subcommand that spawns a Psy Shell with autoload integ

May 23, 2022
Satis-go is a web server for hosting and managing your Satis Repository for Composer Packages

Satis-go download latest Satis-go is a web server for hosting and managing your Satis Repository for Composer Packages Some Highlights: Satis-go provi

Dec 14, 2021
JSONFinder - a library that can find json values in a mixed text or html documents, can filter and search the json tree, and converts php objects to json without 'ext-json' extension.

JSONFinder - a library that can find json values in a mixed text or html documents, can filter and search the json tree, and converts php objects to json without 'ext-json' extension.

Apr 15, 2022
PHP library to easily edit image with GD extension. Resize, crop, merge, draw, and many more options !
PHP library to easily edit image with GD extension. Resize, crop, merge, draw, and many more options !

PHP Image Editor PHP library to easily edit image with GD extension. Resize, crop, merge, draw, and many more options ! ✨ Supporting ⭐ Star this repos

May 11, 2022
Merge Excel Files to single excel file per columns

Merge Excel Files to single excel file per columns

Apr 26, 2021
m4b-tool is a command line utility to merge, split and chapterize audiobook files such as mp3, ogg, flac, m4a or m4b
m4b-tool is a command line utility to merge, split and chapterize audiobook files such as mp3, ogg, flac, m4a or m4b

m4b-tool m4b-tool is a is a wrapper for ffmpeg and mp4v2 to merge, split or and manipulate audiobook files with chapters. Although m4b-tool is designe

May 25, 2022
A redacted PHP port of Underscore.js with additional functions and goodies – Available for Composer and Laravel

Underscore.php The PHP manipulation toolbelt First off : Underscore.php is not a PHP port of Underscore.js (well ok I mean it was at first). It's does

May 24, 2022
PHP runtime & extensions header files for PhpStorm

phpstorm-stubs STUBS are normal, syntactically correct PHP files that contain function & class signatures, constant definitions, etc. for all built-in

May 25, 2022
Simple composer script to manage phar files using project composer.json.
Simple composer script to manage phar files using project composer.json.

tooly-composer-script With tooly composer-script you can version needed PHAR files in your project's composer.json without adding them directly to a V

Aug 3, 2021
Check your Composer dependencies at runtime.

Composition Composition provides a lightweight and generic API, that you can use to check your environment at runtime, instead of manually go checking

May 4, 2021
Easily parse your project's Composer configuration, and those of its dependencies, at runtime

Composed This library provides a set of utility functions designed to help you parse your project's Composer configuration, and those of its dependenc

Apr 11, 2021
Allows generate class files parse from json and map json to php object, including multi-level and complex objects;

nixihz/php-object Allows generate class files parse from json and map json to php object, including multi-level and complex objects; Installation You

Oct 29, 2021
Webird was created to merge the latest PHP and Node.js innovations into a single application stack.

Webird full application stack Webird was created to merge the latest PHP and Node.js innovations into a single application stack. The PHP foundation i

Aug 13, 2020
Merge of staudenmeir/eloquent-eager-limit and staudenmeir/laravel-adjacency-list

This Laravel package merges staudenmeir/eloquent-eager-limit and staudenmeir/laravel-adjacency-list to allow them being used in the same model.

Mar 21, 2022