create-prisma-php-app 1.0.0

package/vendor/hidehalo/nanoid-php/README.md

@@ -0,0 +1,108 @@
+# Nanoid-php
+
+[![Build Status](https://travis-ci.org/hidehalo/emoji.svg)](https://travis-ci.org/hidehalo/nanoid-php)
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fhidehalo%2Fnanoid-php.svg?type=shield)](https://app.fossa.com/projects/git%2Bgithub.com%2Fhidehalo%2Fnanoid-php?ref=badge_shield)
+
+> A tiny (179 bytes), secure URL-friendly unique string ID generator for JavaScript
+>
+> **Safe.** It uses cryptographically strong random APIs and guarantees a proper distribution of symbols.
+>
+> **Small.** Only 179 bytes (minified and gzipped). No dependencies. It uses Size Limit to control size.
+>
+> **Compact.** It uses more symbols than UUID (A-Za-z0-9_\-) and has the same number of unique options in just 21 symbols instead of 36.
+
+Thanks awesome [ai](https://github.com/ai) and his [nanoid](https://github.com/ai/nanoid), this package is a copy in PHP!
+If you like nanoid and you want to use it in PHP, try me :D
+
+## Install
+
+Via Composer
+
+``` bash
+composer require hidehalo/nanoid-php
+```
+
+## Usage
+
+### Normal
+
+> The main module uses URL-friendly symbols (A-Za-z0-9_\-) and returns an ID with 21 characters (to have the same collisions probability as UUID v4).
+
+``` php
+use Hidehalo\Nanoid\Client;
+use Hidehalo\Nanoid\GeneratorInterface;
+
+$client = new Client();
+
+# default random generator
+echo $client->generateId($size = 21);
+# more safer random generator
+echo $client->generateId($size = 21, $mode = Client::MODE_DYNAMIC);
+```
+
+### Custom Alphabet or Length
+
+``` php
+echo $client->formattedId($alphabet = '0123456789abcdefg', $size = 21);
+```
+
+> Alphabet must contain 256 symbols or less.
+> Otherwise, the generator will not be secure.
+
+### Custom Random Bytes Generator
+
+``` php
+# PS: anonymous class is new feature when PHP_VERSION >= 7.0
+echo $client->formattedId($alphabet = '0123456789abcdefg', $size = 21,
+new class implements GeneratorInterface {
+    /**
+     * @inheritDoc
+     */
+    public function random($size)
+    {
+        //TODO: implemenation ...
+    }
+});
+```
+
+> `random` callback must accept the array size and return an array with random numbers.
+>
+> If you want to use the same URL-friendly symbols with `format`,
+> you can get default alphabet from the `url` module:
+
+Please see [`CoreInterface::random(...)`](src/CoreInterface.php) for the core random API prototype and notes
+
+## Examples
+
+Please see [Examples](examples) for more information on detailed usage.
+
+## Change log
+
+Please see [CHANGELOG](CHANGELOG.md) for more information on what has changed recently.
+
+## Testing
+
+``` bash
+composer test
+```
+
+## Contributing
+
+Please see [CONTRIBUTING](CONTRIBUTING.md) and [CODE_OF_CONDUCT](CODE_OF_CONDUCT.md) for details.
+
+## Notice
+
+If you have any issues, just feel free and open it in this repository, thx!
+
+## Credits
+
+- [ai](https://github.com/ai)
+- [hidehalo](https://github.com/hidehalo)
+- [All Contributors](https://github.com/hidehalo/nanoid-php/graphs/contributors)
+
+## License
+
+The MIT License (MIT). Please see [License File](LICENSE.md) for more information.
+
+
+[![FOSSA Status](https://app.fossa.com/api/projects/git%2Bgithub.com%2Fhidehalo%2Fnanoid-php.svg?type=large)](https://app.fossa.com/projects/git%2Bgithub.com%2Fhidehalo%2Fnanoid-php?ref=badge_large)

package/vendor/hidehalo/nanoid-php/benchmark/benchmark.php

@@ -0,0 +1,24 @@
+<?php
+require __DIR__.'/../vendor/autoload.php';
+
+use Hidehalo\Nanoid\Client;
+
+$nano = new Client();
+$loop = 1e5;
+$alphabet = 'abcdefghijklmnopqrstuvwxyz';
+$counter = [];
+
+$timeStated = microtime(true);
+for ($i = 0; $i < $loop; $i++) {
+    $alpha = $nano->formattedId($alphabet, 1);
+    !isset($counter[$alpha]) and $counter[$alpha] = 0;
+    isset($counter[$alpha]) and $counter[$alpha]++;
+}
+$timeFinished = microtime(true);
+$deltaTime = $timeFinished - $timeStated;
+
+ksort($counter);
+printf("Total time used: %.3f ms\n", 1e3 * $deltaTime);
+printf("AVG time used: %.3f ms\n", 1e3 * $deltaTime/$loop);
+echo "Result:".PHP_EOL;
+print_r($counter);

package/vendor/hidehalo/nanoid-php/composer.json

@@ -0,0 +1,62 @@
+{
+    "name": "hidehalo/nanoid-php",
+    "type": "library",
+    "description": "A copy of nanoid in PHP",
+    "keywords": [
+        "hidehalo",
+        "nanoid-php"
+    ],
+    "homepage": "https://github.com/hidehalo/nanoid-php",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "hidehalo",
+            "email": "tianchen_cc@yeah.net",
+            "homepage": "https://github.com/hidehalo",
+            "role": "Owner"
+        }
+    ],
+    "require": {
+        "php": "~5.6|~7.0|~8.0",
+        "paragonie/random_compat": ">=2.0"
+    },
+    "require-dev": {
+        "phpunit/phpunit" : ">=5.6",
+        "squizlabs/php_codesniffer": "^2.3"
+    },
+    "archive": {
+        "exclude": [
+            "tests/",
+            "benchmark/",
+            "examples/",
+            ".gitignore",
+            ".editorconfig",
+            "*.md",
+            "*.yml",
+            "*.xml"
+        ]
+    },
+    "autoload": {
+        "psr-4": {
+            "Hidehalo\\Nanoid\\": "src"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Hidehalo\\Nanoid\\Test\\": "tests"
+        }
+    },
+    "scripts": {
+        "test": "phpunit",
+        "check-style": "phpcs -p --standard=PSR2 --runtime-set ignore_errors_on_exit 1 --runtime-set ignore_warnings_on_exit 1 src tests",
+        "fix-style": "phpcbf -p --standard=PSR2 --runtime-set ignore_errors_on_exit 1 --runtime-set ignore_warnings_on_exit 1 src tests"
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.0-dev"
+        }
+    },
+    "config": {
+        "sort-packages": true
+    }
+}

package/vendor/hidehalo/nanoid-php/examples/basic_usage.php

@@ -0,0 +1,24 @@
+<?php
+require __DIR__.'/../vendor/autoload.php';
+
+use Hidehalo\Nanoid\Client;
+
+$nano = new Client();
+$size = 5;
+//Random bytes that is the performance killer,
+//open a PR if you have more fast and secure implements plz!
+printf("%s\n", str_repeat('-', 64));
+$start = microtime(true);
+random_bytes($size);
+$end = microtime(true);
+$delta = ($end - $start) * 1e3;
+printf("Generate random bytes used: %.6f ms ...\n", $delta);
+
+$id = $nano->generateId($size);
+printf("%s\n", str_repeat('-', 64));
+printf("That is nanoid.id: %s\n", $id);
+printf("%s\n", str_repeat('-', 64));
+
+$id = $nano->generateId($size, Client::MODE_DYNAMIC);
+printf("That is more safer nanoid.id: %s\n", $id);
+printf("%s\n", str_repeat('-', 64));

package/vendor/hidehalo/nanoid-php/examples/custom_formated.php

@@ -0,0 +1,29 @@
+<?php
+require __DIR__.'/../vendor/autoload.php';
+
+use Hidehalo\Nanoid\Client;
+use Hidehalo\Nanoid\GeneratorInterface;
+
+class DummyGenerator implements GeneratorInterface
+{
+    /**
+     * @inheritDoc
+     */
+    public function random($size)
+    {
+        $ret = [];
+        while ($size--) {
+            $ret[] = mt_rand(0, 255);
+        }
+
+        return $ret;
+    }
+}
+
+$nano = new Client();
+$alphabet = '0123456789';
+$nanoId = $nano->formattedId($alphabet, 10);
+$dummyId = $nano->formattedId($alphabet, 10, new DummyGenerator);
+
+printf("Default nano ID: %s\n", $nanoId);
+printf("Formatted nano ID: %s\n", $dummyId);

package/vendor/hidehalo/nanoid-php/phpunit.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<phpunit bootstrap="vendor/autoload.php"
+         backupGlobals="false"
+         backupStaticAttributes="false"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnError="false"
+         stopOnFailure="false"
+         stopOnIncomplete="false"
+         stopOnSkipped="false"
+         colors="true"
+         verbose="true">
+
+    <testsuites>
+        <testsuite name="Unit Tests">
+            <directory suffix="Test.php">tests</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist processUncoveredFilesFromWhitelist="true">
+            <directory suffix=".php">src/</directory>
+            <exclude>
+                <directory suffix=".php">tests/</directory>
+                <file>tests/</file>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>

package/vendor/hidehalo/nanoid-php/src/Client.php

@@ -0,0 +1,120 @@
+<?php
+namespace Hidehalo\Nanoid;
+
+class Client
+{
+    /**
+     * Random mode flags
+     *
+     * @const MODE_NORMAL 1
+     * @const MODEL_DYNAMIC 2
+     */
+    const MODE_NORMAL = 1;
+    const MODE_DYNAMIC = 2;
+
+    /**
+     * @param string $alphabet Symbols to be used in ID.
+     * @param integer $size number of symbols in ID.
+     */
+    protected $alphabet;
+    protected $size;
+
+    /**
+     * @var CoreInterface $core Core dynamic random
+     */
+    private $core;
+
+    /**
+     * @var GeneratorInterface $generator Random Btyes Generator
+     */
+    protected $generator;
+
+    /**
+     * Constructor of Client
+     *
+     * @codeCoverageIgnore
+     * @param integer $size
+     * @param GeneratorInterface $generator
+     */
+    public function __construct($size = 21, GeneratorInterface $generator = null)
+    {
+        $this->size = $size > 0 ? $size : 21;
+        $this->generator = $generator ?: new Generator();
+        $this->core = new Core();
+        $this->alphabet = CoreInterface::SAFE_SYMBOLS;
+    }
+
+    /**
+     * Generate nanoid via optional modes
+     *
+     * @param integer $size
+     * @param integer $mode Client::MODE_NORMAL|Client::MODE_DYNAMIC
+     * @return string
+     */
+    public function generateId($size = 0, $mode = self::MODE_NORMAL)
+    {
+        $size = $size > 0 ? $size : $this->size;
+        switch ($mode) {
+            case self::MODE_DYNAMIC:
+                return $this->core->random($this->generator, $size, $this->alphabet);
+            default:
+                return $this->normalRandom($size);
+        }
+    }
+
+    /**
+     * The original API of nanoid. Use it be careful, Please make sure
+     * you have been implements your custom GeneratorInterface as correctly.
+     * Otherwise use the build-in default random bytes generator
+     *
+     * @param GeneratorInterface $generator
+     * @param integer $size
+     * @param string $alphabet default CoreInterface::SAFE_SYMBOLS
+     * @return string
+     */
+    public function formattedId($alphabet, $size = 0, GeneratorInterface $generator = null)
+    {
+        $alphabet = $alphabet ?: CoreInterface::SAFE_SYMBOLS;
+        $size = $size > 0 ? $size : $this->size;
+        $generator = $generator ?: $this->generator;
+
+        return $this->core->random($generator, $size, $alphabet);
+    }
+
+    /**
+     * Backwards-compatible method name.
+     *
+     * @param string $alphabet
+     * @param integer $size
+     * @param GeneratorInterface $generator
+     *
+     * @return string
+     * @since 1.0.0
+     */
+    public function formatedId($alphabet, $size = 0, GeneratorInterface $generator = null)
+    {
+        $size = $size > 0 ? $size : $this->size;
+
+        return $this->formattedId($alphabet, $size, $generator);
+    }
+
+    /**
+     * Generate secure URL-friendly unique ID.
+     * By default, ID will have 21 symbols to have same collisions probability
+     * as UUID v4.
+     *
+     * @see https://github.com/ai/nanoid/blob/master/non-secure/index.js#L19
+     * @param integer $size
+     * @return string
+     */
+    private function normalRandom($size)
+    {
+        $id = '';
+        while (1 <= $size--) {
+            $rand = mt_rand() / (mt_getrandmax() + 1);
+            $id .= $this->alphabet[intval($rand * 64)];
+        }
+
+        return $id;
+    }
+}

package/vendor/hidehalo/nanoid-php/src/Core.php

@@ -0,0 +1,31 @@
+<?php
+namespace Hidehalo\Nanoid;
+
+class Core implements CoreInterface
+{
+    /**
+     * @inheritDoc
+     * @see https://github.com/ai/nanoid/blob/master/async/index.browser.js#L4
+     */
+    public function random(GeneratorInterface $generator, $size, $alphabet = CoreInterface::SAFE_SYMBOLS)
+    {
+        $len = strlen($alphabet);
+        $mask = (2 << (int) (log($len - 1) / M_LN2)) - 1;
+        $step = (int) ceil(1.6 * $mask * $size / $len);
+        $id = '';
+        while (true) {
+            $bytes = $generator->random($step);
+            // NOTE: `$bytes` maybe not a normal "Array"
+            // sometimes it's begin from index 1, use iterator please
+            foreach ($bytes as $byte) {
+                $byte &= $mask;
+                if (isset($alphabet[$byte])) {
+                    $id .= $alphabet[$byte];
+                    if (strlen($id) === $size) {
+                        return $id;
+                    }
+                }
+            }
+        }
+    }
+}

package/vendor/hidehalo/nanoid-php/src/CoreInterface.php

@@ -0,0 +1,19 @@
+<?php
+namespace Hidehalo\Nanoid;
+
+interface CoreInterface
+{
+    const SAFE_SYMBOLS = '_-0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const MASKS = [15, 31, 63, 127, 255];
+
+    /**
+     * Secure random string generator with custom alphabet.
+     * Alphabet must contain 256 symbols or less. Otherwise, the generator
+     * will not be secure.
+     *
+     * @param GeneratorInterface $generator
+     * @param string $alphabet
+     * @param integer $size
+     */
+    public function random(GeneratorInterface $generator, $size, $alphabet = CoreInterface::SAFE_SYMBOLS);
+}

package/vendor/hidehalo/nanoid-php/src/Generator.php

@@ -0,0 +1,13 @@
+<?php
+namespace Hidehalo\Nanoid;
+
+class Generator implements GeneratorInterface
+{
+    /**
+     * @inheritDoc
+     */
+    public function random($size)
+    {
+        return unpack('C*', \random_bytes($size));
+    }
+}

package/vendor/hidehalo/nanoid-php/src/GeneratorInterface.php

@@ -0,0 +1,13 @@
+<?php
+namespace Hidehalo\Nanoid;
+
+interface GeneratorInterface
+{
+    /**
+     * Return random bytes array
+     *
+     * @param integer $size
+     * @return array
+     */
+    public function random($size);
+}

package/vendor/hidehalo/nanoid-php/tests/ClientTest.php

@@ -0,0 +1,76 @@
+<?php
+namespace Hidehalo\Nanoid\Test;
+
+use Hidehalo\Nanoid\Client;
+use PHPUnit\Framework\TestCase;
+use Hidehalo\Nanoid\Test\Support\DummyGenerator;
+
+class ClientTest extends TestCase
+{
+    /**
+     * @group passed
+     * @dataProvider clientProvider
+     * @param Client $client
+     */
+    public function testGenerateId(Client $client)
+    {
+        $size = 7;
+        $normalRandom = $client->generateId($size);
+        $this->assertEquals($size, strlen($normalRandom));
+        $this->assertNotEquals(str_repeat('_', $size), $normalRandom);
+        $dynamicRandom = $client->generateId($size, Client::MODE_DYNAMIC);
+        $this->assertEquals($size, strlen($dynamicRandom));
+        $this->assertNotEquals($normalRandom, $dynamicRandom);
+        $defaultRandom = $client->generateId();
+        $this->assertEquals(21, strlen($defaultRandom));
+        $this->assertNotEquals(str_repeat('_', 21), $defaultRandom);
+    }
+
+    /**
+     * @group passed
+     * @dataProvider clientProvider
+     * @param Client $client
+     */
+    public function testFormattedId(Client $client)
+    {
+        $size = 10;
+        $alphabet = '0123456789abcdefghi';
+        $id = $client->formattedId($alphabet, $size);
+        $this->assertEquals($size, strlen($id));
+        $dummyId = $client->formattedId($alphabet, $size, new DummyGenerator);
+        $this->assertEquals($size, strlen($dummyId));
+        $this->assertNotEquals($id, $dummyId);
+        $defaultSizeId = $client->formattedId($alphabet);
+        $this->assertEquals(21, strlen($defaultSizeId));
+    }
+
+    /**
+     * @group passed
+     * @dataProvider clientProvider
+     * @param Client $client
+     */
+    public function testFormatedId(Client $client)
+    {
+        $size = 10;
+        $alphabet = '0123456789abcdefghi';
+        $id = $client->formatedId($alphabet, $size);
+        $this->assertEquals($size, strlen($id));
+        $dummyId = $client->formatedId($alphabet, $size, new DummyGenerator);
+        $this->assertEquals($size, strlen($dummyId));
+        $this->assertNotEquals($id, $dummyId);
+        $defaultSizeId = $client->formatedId($alphabet);
+        $this->assertEquals(21, strlen($defaultSizeId));
+    }
+
+    /**
+     * Client Provider
+     *
+     * @return mixed
+     */
+    public function clientProvider()
+    {
+        return [
+            [new Client()]
+        ];
+    }
+}

package/vendor/hidehalo/nanoid-php/tests/CoreTest.php

@@ -0,0 +1,37 @@
+<?php
+namespace Hidehalo\Nanoid\Test;
+
+use Hidehalo\Nanoid\Core;
+use Hidehalo\Nanoid\CoreInterface;
+use Hidehalo\Nanoid\Generator;
+use Hidehalo\Nanoid\GeneratorInterface;
+use PHPUnit\Framework\TestCase;
+
+class CoreTest extends TestCase
+{
+    /**
+     * @group passed
+     * @dataProvider coreProvider
+     * @param CoreInterface $core
+     * @param GeneratorInterface $generator
+     */
+    public function testRandom(CoreInterface $core, GeneratorInterface $generator)
+    {
+        $alph = 'abcdefghijk0123456789';
+        $size = 5;
+        $ret = $core->random($generator, $size, $alph);
+        $this->assertEquals($size, strlen($ret));
+    }
+
+    /**
+     * Core Provider
+     *
+     * @return mixed
+     */
+    public function coreProvider()
+    {
+        return [
+            [new Core(), new Generator()]
+        ];
+    }
+}

package/vendor/hidehalo/nanoid-php/tests/GeneratorTest.php

@@ -0,0 +1,34 @@
+<?php
+namespace Hidehalo\Nanoid\Test;
+
+use PHPUnit\Framework\TestCase;
+use Hidehalo\Nanoid\Generator;
+use Hidehalo\Nanoid\GeneratorInterface;
+
+class GeneratorTest extends TestCase
+{
+
+    /**
+     * @group passed
+     * @dataProvider generatorProvider
+     * @param CoreInterface $core
+     */
+    public function testRandom(GeneratorInterface $generator)
+    {
+        $size = 5;
+        $ret = $generator->random($size);
+        $this->assertEquals($size, count($ret));
+    }
+
+    /**
+     * Generator Provider
+     *
+     * @return mixed
+     */
+    public function generatorProvider()
+    {
+        return [
+            [new Generator()]
+        ];
+    }
+}

package/vendor/hidehalo/nanoid-php/tests/Support/DummyGenerator.php

@@ -0,0 +1,20 @@
+<?php
+namespace Hidehalo\Nanoid\Test\Support;
+
+use Hidehalo\Nanoid\GeneratorInterface;
+
+class DummyGenerator implements GeneratorInterface
+{
+    /**
+     * @inheritDoc
+     */
+    public function random($size)
+    {
+        $ret = [];
+        while ($size--) {
+            $ret[] = mt_rand(0, 255);
+        }
+
+        return $ret;
+    }
+}

package/vendor/paragonie/random_compat/.gitattributes

@@ -0,0 +1,14 @@
+* text=auto
+
+/tests export-ignore
+/.gitattributes export-ignore
+/.gitignore export-ignore
+/.scrutinizer.yml export-ignore
+/.travis.yml export-ignore
+/CHANGELOG.md export-ignore
+/RATIONALE.md export-ignore
+/README.md export-ignore
+/SECURITY.md export-ignore
+/phpunit.sh export-ignore
+/phpunit.xml.dist export-ignore
+/other/ide_stubs export-ignore

package/vendor/paragonie/random_compat/.scrutinizer.yml

@@ -0,0 +1,4 @@
+checks:
+    php:
+        code_rating: true
+        duplication: false