create-prisma-php-app 1.0.0 → 1.0.2

package/vendor/ramsey/uuid/docs/rfc4122/version7.rst

@@ -1,173 +0,0 @@
-.. _rfc4122.version7:
-
-==========================
-Version 7: Unix Epoch Time
-==========================
-
-.. note::
-
-    Version 7, Unix Epoch time UUIDs are a new format of UUID, proposed in an
-    `Internet-Draft under review`_ at the IETF. While the draft is still going
-    through the IETF process, the version 7 format is not expected to change
-    in any way that breaks compatibility.
-
-.. admonition:: ULIDs and Version 7 UUIDs
-    :class: hint
-
-    Version 7 UUIDs are binary-compatible with `ULIDs`_ (universally unique
-    lexicographically-sortable identifiers).
-
-    Both use a 48-bit timestamp in milliseconds since the Unix Epoch, filling
-    the rest with random data. Version 7 UUIDs then add the version and variant
-    bits required by the UUID specification, which reduces the randomness from
-    80 bits to 74. Otherwise, they are identical.
-
-    You may even convert a version 7 UUID to a ULID.
-    :ref:`See below for an example. <rfc4122.version7.ulid>`
-
-Version 7 UUIDs solve `two problems that have long existed`_ with the use of
-:ref:`version 1 <rfc4122.version1>` UUIDs:
-
-1. Scattered database records
-2. Inability to sort by an identifier in a meaningful way (i.e., insert order)
-
-To overcome these issues, we need the ability to generate UUIDs that are
-*monotonically increasing*.
-
-:ref:`Version 6 UUIDs <rfc4122.version6>` provide an excellent solution for
-those who need monotonically increasing, sortable UUIDs with the features of
-version 1 UUIDs (MAC address and clock sequence), but if those features aren't
-necessary for your application, using a version 6 UUID might be overkill.
-
-Version 7 UUIDs combine random data (like version 4 UUIDs) with a timestamp (in
-milliseconds since the Unix Epoch, i.e., 1970-01-01 00:00:00 UTC) to create a
-monotonically increasing, sortable UUID that doesn't have any privacy concerns,
-since it doesn't include a MAC address.
-
-For this reason, implementations should use version 7 UUIDs over versions 1 and
-6, if possible.
-
-.. code-block:: php
-    :caption: Generate a version 7, Unix Epoch time UUID
-    :name: rfc4122.version7.example
-
-    use Ramsey\Uuid\Uuid;
-
-    $uuid = Uuid::uuid7();
-
-    printf(
-        "UUID: %s\nVersion: %d\nDate: %s\n",
-        $uuid->toString(),
-        $uuid->getFields()->getVersion(),
-        $uuid->getDateTime()->format('r'),
-    );
-
-This will generate a version 7 UUID and print out its string representation and
-the time it was created.
-
-It will look something like this:
-
-.. code-block:: text
-
-    UUID: 01833ce0-3486-7bfd-84a1-ad157cf64005
-    Version: 7
-    Date: Wed, 14 Sep 2022 16:41:10 +0000
-
-To use an existing date and time to generate a version 7 UUID, you may pass a
-``\DateTimeInterface`` instance to the ``uuid7()`` method.
-
-.. code-block:: php
-    :caption: Generate a version 7 UUID from an existing date and time
-    :name: rfc4122.version7.example-datetime
-
-    use DateTimeImmutable;
-    use Ramsey\Uuid\Uuid;
-
-    $dateTime = new DateTimeImmutable('@281474976710.655');
-    $uuid = Uuid::uuid7($dateTime);
-
-    printf(
-        "UUID: %s\nVersion: %d\nDate: %s\n",
-        $uuid->toString(),
-        $uuid->getFields()->getVersion(),
-        $uuid->getDateTime()->format('r'),
-    );
-
-Which will print something like this:
-
-.. code-block:: text
-
-    UUID: ffffffff-ffff-7964-a8f6-001336ac20cb
-    Version: 7
-    Date: Tue, 02 Aug 10889 05:31:50 +0000
-
-.. tip::
-
-    Version 7 UUIDs generated in ramsey/uuid are instances of UuidV7. Check out
-    the :php:class:`Ramsey\\Uuid\\Rfc4122\\UuidV7` API documentation to learn
-    more about what you can do with a UuidV7 instance.
-
-
-.. _rfc4122.version7.ulid:
-
-Convert a Version 7 UUID to a ULID
-##################################
-
-As mentioned in the callout above, version 7 UUIDs are binary-compatible with
-`ULIDs`_. This means you can encode a version 7 UUID using `Crockford's Base 32
-algorithm`_ and it will be a valid ULID, timestamp and all.
-
-Using the third-party library `tuupola/base32`_, here's how we can encode a
-version 7 UUID as a ULID. Note that there's a little bit of work to perform the
-conversion, since you're working with different bases.
-
-.. code-block:: php
-    :caption: Encode a version 7, Unix Epoch time UUID as a ULID
-    :name: rfc4122.version7.example-ulid
-
-    use Ramsey\Uuid\Uuid;
-    use Tuupola\Base32;
-
-    $crockford = new Base32([
-        'characters' => Base32::CROCKFORD,
-        'padding' => false,
-        'crockford' => true,
-    ]);
-
-    $uuid = Uuid::uuid7();
-
-    // First, we must pad the 16-byte string to 20 bytes
-    // for proper conversion without data loss.
-    $bytes = str_pad($uuid->getBytes(), 20, "\x00", STR_PAD_LEFT);
-
-    // Use Crockford's Base 32 encoding algorithm.
-    $encoded = $crockford->encode($bytes);
-
-    // That 20-byte string was encoded to 32 characters to avoid loss
-    // of data. We must strip off the first 6 characters--which are
-    // all zeros--to get a valid 26-character ULID string.
-    $ulid = substr($encoded, 6);
-
-    printf("ULID: %s\n", $ulid);
-
-This will print something like this:
-
-.. code-block:: text
-
-    ULID: 01GCZ05N3JFRKBRWKNGCQZGP44
-
-.. caution::
-
-    Be aware that all version 7 UUIDs may be converted to ULIDs but not all
-    ULIDs may be converted to UUIDs.
-
-    For that matter, all UUIDs of any version may be encoded as ULIDs, but they
-    will not be monotonically increasing and sortable unless they are version 7
-    UUIDs. You will also not be able to extract a meaningful timestamp from the
-    ULID, unless it was converted from a version 7 UUID.
-
-.. _ULIDs: https://github.com/ulid/spec
-.. _Internet-Draft under review: https://datatracker.ietf.org/doc/html/draft-ietf-uuidrev-rfc4122bis-00#section-5.7
-.. _two problems that have long existed: https://www.percona.com/blog/2014/12/19/store-uuid-optimized-way/
-.. _Crockford's Base 32 algorithm: https://www.crockford.com/base32.html
-.. _tuupola/base32: https://packagist.org/packages/tuupola/base32

package/vendor/ramsey/uuid/docs/rfc4122/version8.rst

@@ -1,51 +0,0 @@
-.. _rfc4122.version8:
-
-=================
-Version 8: Custom
-=================
-
-.. note::
-
-    Version 8, custom UUIDs are a new format of UUID, proposed in an
-    `Internet-Draft under review`_ at the IETF. While the draft is still going
-    through the IETF process, the version 8 format is not expected to change
-    in any way that breaks compatibility.
-
-Version 8 UUIDs allow applications to create custom UUIDs in an RFC-compatible
-way. The only requirement is the version and variant bits must be set according
-to the UUID specification. The bytes provided may contain any value according to
-your application's needs. Be aware, however, that other applications may not
-understand the semantics of the value.
-
-.. warning::
-
-    The bytes should be a 16-byte octet string, an open blob of data that you
-    may fill with 128 bits of information. However, bits 48 through 51 will be
-    replaced with the UUID version field, and bits 64 and 65 will be replaced
-    with the UUID variant. You must not rely on these bits for your application
-    needs.
-
-.. code-block:: php
-    :caption: Generate a version 8, custom UUID
-    :name: rfc4122.version8.example
-
-    use Ramsey\Uuid\Uuid;
-
-    $uuid = Uuid::uuid8("\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xaa\xbb\xcc\xdd\xee\xff");
-
-    printf(
-        "UUID: %s\nVersion: %d\n",
-        $uuid->toString(),
-        $uuid->getFields()->getVersion()
-    );
-
-This will generate a version 8 UUID and print out its string representation.
-It will look something like this:
-
-.. code-block:: text
-
-    UUID: 00112233-4455-8677-8899-aabbccddeeff
-    Version: 8
-
-
-.. _Internet-Draft under review: https://datatracker.ietf.org/doc/html/draft-ietf-uuidrev-rfc4122bis-00#section-5.8

package/vendor/ramsey/uuid/docs/rfc4122.rst

@@ -1,67 +0,0 @@
-.. _rfc4122:
-
-==============
-RFC 4122 UUIDs
-==============
-
-.. toctree::
-    :titlesonly:
-    :hidden:
-
-    rfc4122/version1
-    rfc4122/version2
-    rfc4122/version3
-    rfc4122/version4
-    rfc4122/version5
-    rfc4122/version6
-    rfc4122/version7
-    rfc4122/version8
-
-`RFC 4122`_ defines five versions of UUID, while a `new Internet-Draft under
-review`_ defines three new versions. Each version has different generation
-algorithms and properties. Which one you choose depends on your use-case. You
-can find out more about their applications on the specific page for that version.
-
-Version 1: Gregorian Time
-    This version of UUID combines a timestamp, node value (in the form of a MAC
-    address from the local computer's network interface), and a clock sequence
-    to ensure uniqueness. For more details, see :doc:`rfc4122/version1`.
-
-Version 2: DCE Security
-    This version of UUID is the same as Version 1, except the ``clock_seq_low``
-    field is replaced with a *local domain* and the ``time_low`` field is
-    replaced with a *local identifier*. For more details, see
-    :doc:`rfc4122/version2`.
-
-Version 3: Name-based (MD5)
-    This version of UUID hashes together a namespace and a name to create a
-    deterministic UUID. The hashing algorithm used is MD5. For more details, see
-    :doc:`rfc4122/version3`.
-
-Version 4: Random
-    This version creates a UUID using truly-random or pseudo-random numbers. For
-    more details, see :doc:`rfc4122/version4`.
-
-Version 5: Named-based (SHA-1)
-    This version of UUID hashes together a namespace and a name to create a
-    deterministic UUID. The hashing algorithm used is SHA-1. For more details,
-    see :doc:`rfc4122/version5`.
-
-Version 6: Reordered Time
-    This version of UUID combines the features of a
-    :ref:`version 1 UUID <rfc4122.version1>` with a *monotonically increasing*
-    UUID. For more details, see :ref:`rfc4122.version6`.
-
-Version 7: Unix Epoch Time
-    This version of UUID combines a timestamp--based on milliseconds elapsed
-    since the Unix Epoch--and random bytes to create a monotonically increasing,
-    sortable UUID without the privacy and entropy concerns associated with
-    version 1 and version 6 UUIDs. For more details, see :ref:`rfc4122.version7`.
-
-Version 8: Custom
-    This version of UUID allows applications to generate custom identifiers in
-    an RFC-compatible format. For more details, see :doc:`rfc4122/version8`.
-
-
-.. _RFC 4122: https://tools.ietf.org/html/rfc4122
-.. _new Internet-Draft under review: https://datatracker.ietf.org/doc/html/draft-ietf-uuidrev-rfc4122bis-00

package/vendor/ramsey/uuid/docs/testing.rst

@@ -1,199 +0,0 @@
-.. _testing:
-
-==================
-Testing With UUIDs
-==================
-
-One problem with the use of ``final`` is the inability to create a `mock object`_
-to use in tests. However, the following techniques should help with testing.
-
-.. tip::
-
-    To learn why ramsey/uuid uses ``final``, take a look at :ref:`faq.final`.
-
-
-.. _testing.inject:
-
-Inject a UUID of a Specific Type
---------------------------------
-
-Let's say we have a method that uses a type hint for :php:class:`UuidV1
-<Ramsey\\Uuid\\Rfc4122\\UuidV1>`.
-
-.. code-block:: php
-
-    public function tellTime(UuidV1 $uuid): string
-    {
-        return $uuid->getDateTime()->format('Y-m-d H:i:s');
-    }
-
-Since this method uses UuidV1 as the type hint, we're not able to pass another
-object that implements UuidInterface, and we cannot extend or mock UuidV1, so
-how do we test this?
-
-One way is to use :php:meth:`Uuid::uuid1() <Ramsey\\Uuid\\Uuid::uuid1>` to
-create a regular UuidV1 instance and pass it.
-
-.. code-block:: php
-
-    public function testTellTime(): void
-    {
-        $uuid = Uuid::uuid1();
-        $myObj = new MyClass();
-
-        $this->assertIsString($myObj->tellTime($uuid));
-    }
-
-This might satisfy our testing needs if we only want to assert that the method
-returns a string. If we want to test for a specific string, we can do that, too,
-by generating a UUID ahead of time and using it as a known value.
-
-.. code-block:: php
-
-    public function testTellTime(): void
-    {
-        // We generated this version 1 UUID ahead of time and know the
-        // exact date and time it contains, so we can use it to test the
-        // return value of our method.
-        $uuid = Uuid::fromString('177ef0d8-6630-11ea-b69a-0242ac130003');
-        $myObj = new MyClass();
-
-        $this->assertSame('2020-03-14 20:12:12', $myObj->tellTime($uuid));
-    }
-
-.. note::
-
-    These examples assume the use of `PHPUnit`_ for tests. The concepts will
-    work no matter what testing framework you use.
-
-
-.. _testing.static:
-
-Returning Specific UUIDs From a Static Method
----------------------------------------------
-
-Sometimes, rather than pass UUIDs as method arguments, we might call the static
-methods on the Uuid class from inside the method we want to test. This can be
-tricky to test.
-
-.. code-block:: php
-
-    public function tellTime(): string
-    {
-        $uuid = Uuid::uuid1();
-
-        return $uuid->getDateTime()->format('Y-m-d H:i:s');
-    }
-
-We can call this in a test and assert that it returns a string, but we can't
-return a specific UUID value from the static method call --- or can we?
-
-We can do this by :ref:`overriding the default factory <customize.factory>`.
-
-First, we create our own factory class for testing. In this example, we extend
-UuidFactory, but you may create your own separate factory class for testing, as
-long as you implement :php:interface:`Ramsey\\Uuid\\UuidFactoryInterface`.
-
-.. code-block:: php
-
-    namespace MyPackage;
-
-    use Ramsey\Uuid\UuidFactory;
-    use Ramsey\Uuid\UuidInterface;
-
-    class MyTestUuidFactory extends UuidFactory
-    {
-        public $uuid1;
-
-        public function uuid1($node = null, ?int $clockSeq = null): UuidInterface
-        {
-            return $this->uuid1;
-        }
-    }
-
-Now, from our tests, we can replace the default factory with our new factory,
-and we can even change the value returned by the :php:meth:`uuid1()
-<Ramsey\\Uuid\\UuidFactoryInterface::uuid1>` method for our tests.
-
-.. code-block:: php
-
-    /**
-     * @runInSeparateProcess
-     * @preserveGlobalState disabled
-     */
-    public function testTellTime(): void
-    {
-        $factory = new MyTestUuidFactory();
-        Uuid::setFactory($factory);
-
-        $myObj = new MyClass();
-
-        $factory->uuid1 = Uuid::fromString('177ef0d8-6630-11ea-b69a-0242ac130003');
-        $this->assertSame('2020-03-14 20:12:12', $myObj->tellTime());
-
-        $factory->uuid1 = Uuid::fromString('13814000-1dd2-11b2-9669-00007ffffffe');
-        $this->assertSame('1970-01-01 00:00:00', $myObj->tellTime());
-    }
-
-.. attention::
-
-    The factory is a static property on the Uuid class. By replacing it like
-    this, all uses of the Uuid class after this point will continue to use the
-    new factory. This is why we must run the test in a separate process.
-    Otherwise, this could cause other tests to fail.
-
-    Running tests in separate processes can significantly slow down your tests,
-    so try to use this technique sparingly, and if possible, pass your
-    dependencies to your objects, rather than creating (or fetching them) from
-    within. This makes testing easier.
-
-
-.. _testing.mock:
-
-Mocking UuidInterface
----------------------
-
-Another technique for testing with UUIDs is to mock
-:php:interface:`UuidInterface <Ramsey\\Uuid\\UuidInterface>`.
-
-Consider a method that accepts a UuidInterface.
-
-.. code-block:: php
-
-    public function tellTime(UuidInterface $uuid): string
-    {
-        return $uuid->getDateTime()->format('Y-m-d H:i:s');
-    }
-
-We can mock UuidInterface, passing that mocked value into this method. Then, we
-can make assertions about what methods were called on the mock object. In the
-following example test, we don't care whether the return value matches an
-actual date format. What we care about is that the methods on the UuidInterface
-object were called.
-
-.. code-block:: php
-
-    public function testTellTime(): void
-    {
-        $dateTime = Mockery::mock(DateTime::class);
-        $dateTime->expects()->format('Y-m-d H:i:s')->andReturn('a test date');
-
-        $uuid = Mockery::mock(UuidInterface::class, [
-            'getDateTime' => $dateTime,
-        ]);
-
-        $myObj = new MyClass();
-
-        $this->assertSame('a test date', $myObj->tellTime($uuid));
-    }
-
-.. note::
-
-    One of my favorite mocking libraries is `Mockery`_, so that's what I use in
-    these examples. However, other mocking libraries exist, and PHPUnit provides
-    built-in mocking capabilities.
-
-
-.. _mock object: https://en.wikipedia.org/wiki/Mock_object
-.. _PHPUnit: https://phpunit.de
-.. _Mockery: https://github.com/mockery/mockery

package/vendor/ramsey/uuid/docs/tidelift.rst

@@ -1,74 +0,0 @@
-.. role:: btn-info
-    :class: btn btn-info
-
-.. role:: btn-neutral
-    :class: btn btn-neutral
-
-.. |nbsp| unicode:: 0xA0
-    :trim:
-
-.. |Learn More| replace:: :btn-neutral:`Learn More`
-.. _Learn More: https://tidelift.com/subscription/pkg/packagist-ramsey-uuid?utm_source=undefined&utm_medium=referral&utm_campaign=enterprise
-.. |Request a Demo| replace:: :btn-info:`Request a Demo`
-.. _Request a Demo: https://tidelift.com/subscription/request-a-demo?utm_source=undefined&utm_medium=referral&utm_campaign=enterprise
-
-.. _tidelift:
-
-==========================
-ramsey/uuid for Enterprise
-==========================
-
-.. rubric:: Available as part of the Tidelift Subscription
-
-Tidelift is working with the maintainers of ramsey/uuid and thousands of other
-open source projects to deliver commercial support and maintenance for the open
-source dependencies you use to build your applications. Save time, reduce risk,
-and improve code health, while paying the maintainers of the exact dependencies
-you use.
-
-.. centered:: |Learn More|_ |nbsp| |nbsp| |nbsp| |Request a Demo|_
-
-.. rubric:: Enterprise-ready open source software --- managed for you
-
-The Tidelift Subscription is a managed open source subscription for application
-dependencies covering millions of open source projects across JavaScript,
-Python, Java, PHP, Ruby, .NET, and more.
-
-Your subscription includes:
-
-Security updates
-    Tidelift’s security response team coordinates patches for new breaking
-    security vulnerabilities and alerts immediately through a private channel,
-    so your software supply chain is always secure.
-
-Licensing verification and indemnification
-    Tidelift verifies license information to enable easy policy enforcement and
-    adds intellectual property indemnification to cover creators and users in
-    case something goes wrong. You always have a 100% up-to-date bill of
-    materials for your dependencies to share with your legal team, customers,
-    or partners.
-
-Maintenance and code improvement
-    Tidelift ensures the software you rely on keeps working as long as you need
-    it to work. Your managed dependencies are actively maintained and we recruit
-    additional maintainers where required.
-
-Package selection and version guidance
-    We help you choose the best open source packages from the start—and then
-    guide you through updates to stay on the best releases as new issues arise.
-
-Roadmap input
-    Take a seat at the table with the creators behind the software you use.
-    Tidelift’s participating maintainers earn more income as their software is
-    used by more subscribers, so they’re interested in knowing what you need.
-
-Tooling and cloud integration
-    Tidelift works with GitHub, GitLab, BitBucket, and more. We support every
-    cloud platform (and other deployment targets, too).
-
-The end result? All of the capabilities you expect from commercial-grade
-software, for the full breadth of open source you use. That means less time
-grappling with esoteric open source trivia, and more time building your own
-applications—and your business.
-
-.. centered:: |Learn More|_ |nbsp| |nbsp| |nbsp| |Request a Demo|_

package/vendor/ramsey/uuid/docs/upgrading/2-to-3.rst

@@ -1,31 +0,0 @@
-.. _upgrading.2-to-3:
-
-==============
-Version 2 to 3
-==============
-
-While we have made significant internal changes to the library, we have made
-every effort to ensure a seamless upgrade path from the 2.x series of this
-library to 3.x.
-
-One major breaking change is the transition from the ``Rhumsaa`` root namespace
-to ``Ramsey``. In most cases, all you will need is to change the namespace to
-``Ramsey`` in your code, and everything will "just work."
-
-.. note::
-    For more details on the namespace change, including reasons for the change,
-    read the blog post "`Introducing ramsey/uuid
-    <https://benramsey.com/blog/2016/04/ramsey-uuid/>`_".
-
-Here are full details on the breaking changes to the public API of this library:
-
-1. All namespace references of ``Rhumsaa`` have changed to ``Ramsey``. Simply
-   change the namespace to ``Ramsey`` in your code and everything should work.
-2. The console application has moved to
-   `ramsey/uuid-console <https://packagist.org/packages/ramsey/uuid-console>`_.
-   If using the console functionality, use Composer to require
-   ``ramsey/uuid-console``.
-3. The Doctrine field type mapping has moved to
-   `ramsey/uuid-doctrine <https://packagist.org/packages/ramsey/uuid-doctrine>`_.
-   If using the Doctrine functionality, use Composer to require
-   ``ramsey/uuid-doctrine``.