binary-collections 2.0.12 → 2.0.14

package/vendor/fidry/cpu-core-counter/README.md

@@ -0,0 +1,138 @@
+# CPU Core Counter
+
+This package is a tiny utility to get the number of CPU cores.
+
+```sh
+composer require fidry/cpu-core-counter
+```
+
+
+## Usage
+
+```php
+use Fidry\CpuCoreCounter\CpuCoreCounter;
+use Fidry\CpuCoreCounter\NumberOfCpuCoreNotFound;
+use Fidry\CpuCoreCounter\Finder\DummyCpuCoreFinder;
+
+$counter = new CpuCoreCounter();
+
+// For knowing the number of cores you can use for launching parallel processes:
+$counter->getAvailableForParallelisation()->availableCpus;
+
+// Get the number of CPU cores (by default it will use the logical cores count):
+try {
+    $counter->getCount();   // e.g. 8
+} catch (NumberOfCpuCoreNotFound) {
+    return 1;   // Fallback value
+}
+
+// An alternative form where we not want to catch the exception:
+
+$counter = new CpuCoreCounter([
+    ...CpuCoreCounter::getDefaultFinders(),
+    new DummyCpuCoreFinder(1),  // Fallback value
+]);
+
+// A type-safe alternative form:
+$counter->getCountWithFallback(1);
+
+// Note that the result is memoized.
+$counter->getCount();   // e.g. 8
+
+```
+
+
+## Advanced usage
+
+### Changing the finders
+
+When creating `CpuCoreCounter`, you may want to change the order of the finders
+used or disable a specific finder. You can easily do so by passing the finders
+you want
+
+```php
+// Remove WindowsWmicFinder 
+$finders = array_filter(
+    CpuCoreCounter::getDefaultFinders(),
+    static fn (CpuCoreFinder $finder) => !($finder instanceof WindowsWmicFinder)
+);
+
+$cores = (new CpuCoreCounter($finders))->getCount();
+```
+
+```php
+// Use CPUInfo first & don't use Nproc
+$finders = [
+    new CpuInfoFinder(),
+    new WindowsWmicFinder(),
+    new HwLogicalFinder(),
+];
+
+$cores = (new CpuCoreCounter($finders))->getCount();
+```
+
+### Choosing only logical or physical finders
+
+`FinderRegistry` provides two helpful entries:
+
+- `::getDefaultLogicalFinders()`: gives an ordered list of finders that will
+  look for the _logical_ CPU cores count.
+- `::getDefaultPhysicalFinders()`: gives an ordered list of finders that will
+  look for the _physical_ CPU cores count.
+
+By default, when using `CpuCoreCounter`, it will use the logical finders since
+it is more likely what you are looking for and is what is used by PHP source to
+build the PHP binary.
+
+
+### Checks what finders find what on your system
+
+You have three scrips available that provides insight about what the finders
+can find:
+
+```shell
+# Checks what each given finder will find on your system with details about the
+# information it had.
+make diagnose                                     # From this repository
+./vendor/fidry/cpu-core-counter/bin/diagnose.php  # From the library
+```
+
+And:
+```shell
+# Execute all finders and display the result they found.
+make execute                                     # From this repository
+./vendor/fidry/cpu-core-counter/bin/execute.php  # From the library
+```
+
+
+### Debug the results found
+
+You have 3 methods available to help you find out what happened:
+
+1. If you are using the default configuration of finder registries, you can check
+   the previous section which will provide plenty of information.
+2. If what you are interested in is how many CPU cores were found, you can use
+   the `CpuCoreCounter::trace()` method.
+3. If what you are interested in is how the calculation of CPU cores available
+   for parallelisation was done, you can inspect the values of `ParallelisationResult`
+   returned by `CpuCoreCounter::getAvailableForParallelisation()`.
+
+
+## Backward Compatibility Promise (BCP)
+
+The policy is for the major part following the same as [Symfony's one][symfony-bc-policy].
+Note that the code marked as `@private` or `@internal` are excluded from the BCP.
+
+The following elements are also excluded:
+
+- The `diagnose` and `execute` commands: those are for debugging/inspection purposes only
+- `FinderRegistry::get*Finders()`: new finders may be added or the order of finders changed at any time
+
+
+## License
+
+This package is licensed using the MIT License.
+
+Please have a look at [`LICENSE.md`](LICENSE.md).
+
+[symfony-bc-policy]: https://symfony.com/doc/current/contributing/code/bc.html

package/vendor/friendsofphp/php-cs-fixer/README.md

@@ -0,0 +1,97 @@
+<p align="center">
+    <a href="https://cs.symfony.com">
+        <img src="./logo.png" title="PHP CS Fixer" alt="PHP CS Fixer logo">
+    </a>
+</p>
+
+# PHP Coding Standards Fixer
+
+The PHP Coding Standards Fixer (PHP CS Fixer) fixes your code to follow the standards.
+
+If you are already using a linter to identify coding standards problems in your
+code, you know that fixing them by hand is tedious, especially on large
+projects. This tool not only detects them, but also fixes them for you.
+
+PHP CS Fixer has built-in rule sets, whether you want to follow PHP coding standards as defined by [PHP-FIG's PER Coding Style](https://www.php-fig.org/per/coding-style/) - [`@PER-CS`](./doc/ruleSets/PER-CS.rst),
+a wide community like the [Symfony](https://symfony.com/doc/current/contributing/code/standards.html) - [`@Symfony`](./doc/ruleSets/Symfony.rst),
+or our opinionated one - [@PhpCsFixer](./doc/ruleSets/PhpCsFixer.rst).
+You can also define your (team's) style through the [configuration file](./doc/config.rst).
+
+PHP CS Fixer can not only unify the style of your code, but also help to modernise your codebase towards
+newer PHP (e.g. [`@autoPHPMigration`](./doc/ruleSets/AutoPHPMigration.rst) and [`@autoPHPMigration:risky`](./doc/ruleSets/AutoPHPMigrationRisky.rst)) and newer PHPUnit (e.g. [`@autoPHPUnitMigration:risky`](./doc/ruleSets/AutoPHPUnitMigrationRisky.rst)).
+
+There are also [`@auto`](./doc/ruleSets/Auto.rst) and [`@auto:risky`](./doc/ruleSets/AutoRisky.rst) that aim to provide good base rules.
+
+## Supported PHP Versions
+
+* PHP 7.4 - PHP 8.5
+
+> [!NOTE]
+> Each new PHP version requires a huge effort to support the new syntax.
+> That's why the latest PHP version might not be supported yet. If you need it,
+> please consider supporting the project in any convenient way, for example,
+> with code contributions or reviewing existing PRs. To run PHP CS Fixer on yet
+> unsupported versions "at your own risk" - use `--allow-unsupported-php-version=yes` option.
+
+## Documentation
+
+### Installation
+
+The recommended way to install PHP CS Fixer is to use [Composer](https://getcomposer.org/download/):
+
+```sh
+composer require --dev friendsofphp/php-cs-fixer
+## or when facing conflicts in dependencies:
+composer require --dev php-cs-fixer/shim
+```
+
+For more details and other installation methods (also with Docker or behind CI), see
+[installation instructions](./doc/installation.rst).
+
+### Usage
+
+Assuming you installed PHP CS Fixer as instructed above, you can
+initialise base config for your project by using following command:
+
+```sh
+./vendor/bin/php-cs-fixer init
+```
+
+To automatically fix your project, or only check against the need of changes, run:
+
+```sh
+./vendor/bin/php-cs-fixer fix
+./vendor/bin/php-cs-fixer check
+```
+
+See [usage](./doc/usage.rst), list of [built-in rules](./doc/rules/index.rst), list of [rule sets](./doc/ruleSets/index.rst)
+and [configuration file](./doc/config.rst) documentation for more details.
+
+If you need to apply code styles that are not built-in into the tool, you can
+[create custom rules](./doc/custom_rules.rst).
+
+## Editor Integration
+
+Native support exists for:
+
+* [PhpStorm](https://www.jetbrains.com/help/phpstorm/using-php-cs-fixer.html)
+
+Community plugins exist for:
+
+* [NetBeans](https://plugins.netbeans.apache.org/catalogue/?id=36)
+* [Sublime Text](https://github.com/benmatselby/sublime-phpcs)
+* [Vim](https://github.com/stephpy/vim-php-cs-fixer)
+* [VS Code](https://github.com/junstyle/vscode-php-cs-fixer)
+
+## Community
+
+The PHP CS Fixer is maintained on GitHub at <https://github.com/PHP-CS-Fixer/PHP-CS-Fixer>.
+Contributions, bug reports and ideas about new features are welcome there.
+
+You can reach us in the [GitHub Discussions](https://github.com/PHP-CS-Fixer/PHP-CS-Fixer/discussions/) regarding the
+project, configuration, possible improvements, ideas and questions.
+
+## Contribute
+
+The tool comes with quite a few built-in fixers, but everyone is more than
+welcome to [contribute](./CONTRIBUTING.md) more of them.

package/vendor/psr/container/README.md

@@ -0,0 +1,13 @@
+Container interface
+==============
+
+This repository holds all interfaces related to [PSR-11 (Container Interface)][psr-url].
+
+Note that this is not a Container implementation of its own. It is merely abstractions that describe the components of a Dependency Injection Container.
+
+The installable [package][package-url] and [implementations][implementation-url] are listed on Packagist.
+
+[psr-url]: https://www.php-fig.org/psr/psr-11/
+[package-url]: https://packagist.org/packages/psr/container
+[implementation-url]: https://packagist.org/providers/psr/container-implementation
+

package/vendor/psr/event-dispatcher/README.md

@@ -0,0 +1,6 @@
+PSR Event Dispatcher
+====================
+
+This repository holds the interfaces related to [PSR-14](http://www.php-fig.org/psr/psr-14/).
+
+Note that this is not an Event Dispatcher implementation of its own. It is merely interfaces that describe the components of an Event Dispatcher.  See the specification for more details.

package/vendor/psr/log/README.md

@@ -0,0 +1,58 @@
+PSR Log
+=======
+
+This repository holds all interfaces/classes/traits related to
+[PSR-3](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md).
+
+Note that this is not a logger of its own. It is merely an interface that
+describes a logger. See the specification for more details.
+
+Installation
+------------
+
+```bash
+composer require psr/log
+```
+
+Usage
+-----
+
+If you need a logger, you can use the interface like this:
+
+```php
+<?php
+
+use Psr\Log\LoggerInterface;
+
+class Foo
+{
+    private $logger;
+
+    public function __construct(LoggerInterface $logger = null)
+    {
+        $this->logger = $logger;
+    }
+
+    public function doSomething()
+    {
+        if ($this->logger) {
+            $this->logger->info('Doing work');
+        }
+           
+        try {
+            $this->doSomethingElse();
+        } catch (Exception $exception) {
+            $this->logger->error('Oh no!', array('exception' => $exception));
+        }
+
+        // do something useful
+    }
+}
+```
+
+You can then pick one of the implementations of the interface to get a logger.
+
+If you want to implement the interface, you can require this package and
+implement `Psr\Log\LoggerInterface` in your code. Please read the
+[specification text](https://github.com/php-fig/fig-standards/blob/master/accepted/PSR-3-logger-interface.md)
+for details.

package/vendor/react/cache/README.md

@@ -0,0 +1,367 @@
+# Cache
+
+[![CI status](https://github.com/reactphp/cache/actions/workflows/ci.yml/badge.svg)](https://github.com/reactphp/cache/actions)
+[![installs on Packagist](https://img.shields.io/packagist/dt/react/cache?color=blue&label=installs%20on%20Packagist)](https://packagist.org/packages/react/cache)
+
+Async, [Promise](https://github.com/reactphp/promise)-based cache interface
+for [ReactPHP](https://reactphp.org/).
+
+The cache component provides a
+[Promise](https://github.com/reactphp/promise)-based
+[`CacheInterface`](#cacheinterface) and an in-memory [`ArrayCache`](#arraycache)
+implementation of that.
+This allows consumers to type hint against the interface and third parties to
+provide alternate implementations.
+This project is heavily inspired by
+[PSR-16: Common Interface for Caching Libraries](https://www.php-fig.org/psr/psr-16/),
+but uses an interface more suited for async, non-blocking applications.
+
+**Table of Contents**
+
+* [Usage](#usage)
+  * [CacheInterface](#cacheinterface)
+    * [get()](#get)
+    * [set()](#set)
+    * [delete()](#delete)
+    * [getMultiple()](#getmultiple)
+    * [setMultiple()](#setmultiple)
+    * [deleteMultiple()](#deletemultiple)
+    * [clear()](#clear)
+    * [has()](#has)
+  * [ArrayCache](#arraycache)
+* [Common usage](#common-usage)
+  * [Fallback get](#fallback-get)
+  * [Fallback-get-and-set](#fallback-get-and-set)
+* [Install](#install)
+* [Tests](#tests)
+* [License](#license)
+
+## Usage
+
+### CacheInterface
+
+The `CacheInterface` describes the main interface of this component.
+This allows consumers to type hint against the interface and third parties to
+provide alternate implementations.
+
+#### get()
+
+The `get(string $key, mixed $default = null): PromiseInterface<mixed>` method can be used to
+retrieve an item from the cache.
+
+This method will resolve with the cached value on success or with the
+given `$default` value when no item can be found or when an error occurs.
+Similarly, an expired cache item (once the time-to-live is expired) is
+considered a cache miss.
+
+```php
+$cache
+    ->get('foo')
+    ->then('var_dump');
+```
+
+This example fetches the value of the key `foo` and passes it to the
+`var_dump` function. You can use any of the composition provided by
+[promises](https://github.com/reactphp/promise).
+
+#### set()
+
+The `set(string $key, mixed $value, ?float $ttl = null): PromiseInterface<bool>` method can be used to
+store an item in the cache.
+
+This method will resolve with `true` on success or `false` when an error
+occurs. If the cache implementation has to go over the network to store
+it, it may take a while.
+
+The optional `$ttl` parameter sets the maximum time-to-live in seconds
+for this cache item. If this parameter is omitted (or `null`), the item
+will stay in the cache for as long as the underlying implementation
+supports. Trying to access an expired cache item results in a cache miss,
+see also [`get()`](#get).
+
+```php
+$cache->set('foo', 'bar', 60);
+```
+
+This example eventually sets the value of the key `foo` to `bar`. If it
+already exists, it is overridden.
+
+This interface does not enforce any particular TTL resolution, so special
+care may have to be taken if you rely on very high precision with
+millisecond accuracy or below. Cache implementations SHOULD work on a
+best effort basis and SHOULD provide at least second accuracy unless
+otherwise noted. Many existing cache implementations are known to provide
+microsecond or millisecond accuracy, but it's generally not recommended
+to rely on this high precision.
+
+This interface suggests that cache implementations SHOULD use a monotonic
+time source if available. Given that a monotonic time source is only
+available as of PHP 7.3 by default, cache implementations MAY fall back
+to using wall-clock time.
+While this does not affect many common use cases, this is an important
+distinction for programs that rely on a high time precision or on systems
+that are subject to discontinuous time adjustments (time jumps).
+This means that if you store a cache item with a TTL of 30s and then
+adjust your system time forward by 20s, the cache item SHOULD still
+expire in 30s.
+
+#### delete()
+
+The `delete(string $key): PromiseInterface<bool>` method can be used to
+delete an item from the cache.
+
+This method will resolve with `true` on success or `false` when an error
+occurs. When no item for `$key` is found in the cache, it also resolves
+to `true`. If the cache implementation has to go over the network to
+delete it, it may take a while.
+
+```php
+$cache->delete('foo');
+```
+
+This example eventually deletes the key `foo` from the cache. As with
+`set()`, this may not happen instantly and a promise is returned to
+provide guarantees whether or not the item has been removed from cache.
+
+#### getMultiple()
+
+The `getMultiple(string[] $keys, mixed $default = null): PromiseInterface<array>` method can be used to
+retrieve multiple cache items by their unique keys.
+
+This method will resolve with an array of cached values on success or with the
+given `$default` value when an item can not be found or when an error occurs.
+Similarly, an expired cache item (once the time-to-live is expired) is
+considered a cache miss.
+
+```php
+$cache->getMultiple(array('name', 'age'))->then(function (array $values) {
+    $name = $values['name'] ?? 'User';
+    $age = $values['age'] ?? 'n/a';
+
+    echo $name . ' is ' . $age . PHP_EOL;
+});
+```
+
+This example fetches the cache items for the `name` and `age` keys and
+prints some example output. You can use any of the composition provided
+by [promises](https://github.com/reactphp/promise).
+
+#### setMultiple()
+
+The `setMultiple(array $values, ?float $ttl = null): PromiseInterface<bool>` method can be used to
+persist a set of key => value pairs in the cache, with an optional TTL.
+
+This method will resolve with `true` on success or `false` when an error
+occurs. If the cache implementation has to go over the network to store
+it, it may take a while.
+
+The optional `$ttl` parameter sets the maximum time-to-live in seconds
+for these cache items. If this parameter is omitted (or `null`), these items
+will stay in the cache for as long as the underlying implementation
+supports. Trying to access an expired cache items results in a cache miss,
+see also [`getMultiple()`](#getmultiple).
+
+```php
+$cache->setMultiple(array('foo' => 1, 'bar' => 2), 60);
+```
+
+This example eventually sets the list of values - the key `foo` to `1` value 
+and the key `bar` to `2`. If some of the keys already exist, they are overridden.
+
+#### deleteMultiple()
+
+The `setMultiple(string[] $keys): PromiseInterface<bool>` method can be used to
+delete multiple cache items in a single operation.
+
+This method will resolve with `true` on success or `false` when an error
+occurs. When no items for `$keys` are found in the cache, it also resolves
+to `true`. If the cache implementation has to go over the network to
+delete it, it may take a while.
+
+```php
+$cache->deleteMultiple(array('foo', 'bar, 'baz'));
+```
+
+This example eventually deletes keys `foo`, `bar` and `baz` from the cache. 
+As with `setMultiple()`, this may not happen instantly and a promise is returned to
+provide guarantees whether or not the item has been removed from cache.
+
+#### clear()
+
+The `clear(): PromiseInterface<bool>` method can be used to
+wipe clean the entire cache.
+
+This method will resolve with `true` on success or `false` when an error
+occurs. If the cache implementation has to go over the network to
+delete it, it may take a while.
+
+```php
+$cache->clear();
+```
+
+This example eventually deletes all keys from the cache. As with `deleteMultiple()`, 
+this may not happen instantly and a promise is returned to provide guarantees 
+whether or not all the items have been removed from cache.
+
+#### has()
+
+The `has(string $key): PromiseInterface<bool>` method can be used to
+determine whether an item is present in the cache.
+
+This method will resolve with `true` on success or `false` when no item can be found 
+or when an error occurs. Similarly, an expired cache item (once the time-to-live 
+is expired) is considered a cache miss.
+
+```php
+$cache
+    ->has('foo')
+    ->then('var_dump');
+```
+
+This example checks if the value of the key `foo` is set in the cache and passes 
+the result to the `var_dump` function. You can use any of the composition provided by
+[promises](https://github.com/reactphp/promise).
+
+NOTE: It is recommended that has() is only to be used for cache warming type purposes
+and not to be used within your live applications operations for get/set, as this method
+is subject to a race condition where your has() will return true and immediately after,
+another script can remove it making the state of your app out of date.
+
+### ArrayCache
+
+The `ArrayCache` provides an in-memory implementation of the [`CacheInterface`](#cacheinterface).
+
+```php
+$cache = new ArrayCache();
+
+$cache->set('foo', 'bar');
+```
+
+Its constructor accepts an optional `?int $limit` parameter to limit the
+maximum number of entries to store in the LRU cache. If you add more
+entries to this instance, it will automatically take care of removing
+the one that was least recently used (LRU).
+
+For example, this snippet will overwrite the first value and only store
+the last two entries:
+
+```php
+$cache = new ArrayCache(2);
+
+$cache->set('foo', '1');
+$cache->set('bar', '2');
+$cache->set('baz', '3');
+```
+
+This cache implementation is known to rely on wall-clock time to schedule
+future cache expiration times when using any version before PHP 7.3,
+because a monotonic time source is only available as of PHP 7.3 (`hrtime()`).
+While this does not affect many common use cases, this is an important
+distinction for programs that rely on a high time precision or on systems
+that are subject to discontinuous time adjustments (time jumps).
+This means that if you store a cache item with a TTL of 30s on PHP < 7.3
+and then adjust your system time forward by 20s, the cache item may
+expire in 10s. See also [`set()`](#set) for more details.
+
+## Common usage
+
+### Fallback get
+
+A common use case of caches is to attempt fetching a cached value and as a
+fallback retrieve it from the original data source if not found. Here is an
+example of that:
+
+```php
+$cache
+    ->get('foo')
+    ->then(function ($result) {
+        if ($result === null) {
+            return getFooFromDb();
+        }
+        
+        return $result;
+    })
+    ->then('var_dump');
+```
+
+First an attempt is made to retrieve the value of `foo`. A callback function is 
+registered that will call `getFooFromDb` when the resulting value is null. 
+`getFooFromDb` is a function (can be any PHP callable) that will be called if the 
+key does not exist in the cache.
+
+`getFooFromDb` can handle the missing key by returning a promise for the
+actual value from the database (or any other data source). As a result, this
+chain will correctly fall back, and provide the value in both cases.
+
+### Fallback get and set
+
+To expand on the fallback get example, often you want to set the value on the
+cache after fetching it from the data source.
+
+```php
+$cache
+    ->get('foo')
+    ->then(function ($result) {
+        if ($result === null) {
+            return $this->getAndCacheFooFromDb();
+        }
+        
+        return $result;
+    })
+    ->then('var_dump');
+
+public function getAndCacheFooFromDb()
+{
+    return $this->db
+        ->get('foo')
+        ->then(array($this, 'cacheFooFromDb'));
+}
+
+public function cacheFooFromDb($foo)
+{
+    $this->cache->set('foo', $foo);
+
+    return $foo;
+}
+```
+
+By using chaining you can easily conditionally cache the value if it is
+fetched from the database.
+
+## Install
+
+The recommended way to install this library is [through Composer](https://getcomposer.org).
+[New to Composer?](https://getcomposer.org/doc/00-intro.md)
+
+This project follows [SemVer](https://semver.org/).
+This will install the latest supported version:
+
+```bash
+composer require react/cache:^1.2
+```
+
+See also the [CHANGELOG](CHANGELOG.md) for details about version upgrades.
+
+This project aims to run on any platform and thus does not require any PHP
+extensions and supports running on legacy PHP 5.3 through current PHP 8+ and
+HHVM.
+It's *highly recommended to use PHP 7+* for this project.
+
+## Tests
+
+To run the test suite, you first need to clone this repo and then install all
+dependencies [through Composer](https://getcomposer.org):
+
+```bash
+composer install
+```
+
+To run the test suite, go to the project root and run:
+
+```bash
+vendor/bin/phpunit
+```
+
+## License
+
+MIT, see [LICENSE file](LICENSE).