Correct spelling & grammar in 5.3

cache.rst

@@ -800,5 +800,5 @@ Then, register the ``SodiumMarshaller`` service using this key:
 
 When configuring multiple keys, the first key will be used for reading and
 writing, and the additional key(s) will only be used for reading. Once all
-cache items encrypted with the old key have expired, you can remove
-``OLD_CACHE_DECRYPTION_KEY`` completely.
+cache items encrypted with the old key have expired, you can completely remove
+``OLD_CACHE_DECRYPTION_KEY``.

components/browser_kit.rst

@@ -185,7 +185,7 @@ Custom Header Handling
 The optional HTTP headers passed to the ``request()`` method follows the FastCGI
 request format (uppercase, underscores instead of dashes and prefixed with ``HTTP_``).
 Before saving those headers to the request, they are lower-cased, with ``HTTP_``
-stripped, and underscores turned to dashes.
+stripped, and underscores converted into dashes.
 
 If you're making a request to an application that has special rules about header
 capitalization or punctuation, override the ``getHeaders()`` method, which must

components/http_foundation.rst

@@ -81,7 +81,7 @@ can be accessed via several public properties:
   (``$request->headers->get('User-Agent')``).
 
 Each property is a :class:`Symfony\\Component\\HttpFoundation\\ParameterBag`
-instance (or a sub-class of), which is a data holder class:
+instance (or a subclass of), which is a data holder class:
 
 * ``request``: :class:`Symfony\\Component\\HttpFoundation\\ParameterBag` or
   :class:`Symfony\\Component\\HttpFoundation\\InputBag` if the data is
@@ -726,7 +726,7 @@ The ``JsonResponse`` class sets the ``Content-Type`` header to
 .. caution::
 
     To avoid XSSI `JSON Hijacking`_, you should pass an associative array
-    as the outer-most array to ``JsonResponse`` and not an indexed array so
+    as the outermost array to ``JsonResponse`` and not an indexed array so
     that the final result is an object (e.g. ``{"object": "not inside an array"}``)
     instead of an array (e.g. ``[{"object": "inside an array"}]``). Read
     the `OWASP guidelines`_ for more information.

components/lock.rst

@@ -210,7 +210,7 @@ as seconds) and ``isExpired()`` (which returns a boolean).
 Automatically Releasing The Lock
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Locks are automatically released when their Lock objects are destructed. This is
+Locks are automatically released when their Lock objects are destroyed. This is
 an implementation detail that will be important when sharing Locks between
 processes. In the example below, ``pcntl_fork()`` creates two processes and the
 Lock will be released automatically as soon as one process finishes::
@@ -508,7 +508,7 @@ locks::
     $store = new PostgreSqlStore($databaseConnectionOrDSN);
 
 In opposite to the ``PdoStore``, the ``PostgreSqlStore`` does not need a table to
-store locks and does not expire.
+store locks and it does not expire.
 
 .. versionadded:: 5.2
 

components/messenger.rst

@@ -77,7 +77,7 @@ middleware stack. The component comes with a set of middleware that you can use.
 When using the message bus with Symfony's FrameworkBundle, the following middleware
 are configured for you:
 
-#. :class:`Symfony\\Component\\Messenger\\Middleware\\SendMessageMiddleware` (enables asynchronous processing, logs the processing of your messages if you pass a logger)
+#. :class:`Symfony\\Component\\Messenger\\Middleware\\SendMessageMiddleware` (enables asynchronous processing, logs the processing of your messages if you provide a logger)
 #. :class:`Symfony\\Component\\Messenger\\Middleware\\HandleMessageMiddleware` (calls the registered handler(s))
 
 Example::

components/phpunit_bridge.rst

@@ -295,7 +295,7 @@ Baseline Deprecations
 If your application has some deprecations that you can't fix for some reasons,
 you can tell Symfony to ignore them. The trick is to create a file with the
 allowed deprecations and define it as the "deprecation baseline". Deprecations
-inside that file are ignore but the rest of deprecations are still reported.
+inside that file are ignored but the rest of deprecations are still reported.
 
 First, generate the file with the allowed deprecations (run the same command
 whenever you want to update the existing file):

components/runtime.rst

@@ -383,7 +383,7 @@ application outside of the global state in 6 steps:
    that knows how to "run" the application object.
 #. The ``RunnerInterface::run(object $application)`` is called and it returns the
    exit status code as `int`.
-#. The PHP engine is exited with this status code.
+#. The PHP engine is terminated with this status code.
 
 When creating a new runtime, there are two things to consider: First, what arguments
 will the end user use? Second, what will the user's application look like?

components/semaphore.rst

@@ -45,7 +45,7 @@ class, which in turn requires another class to manage the storage::
 The semaphore is created by calling the
 :method:`Symfony\\Component\\Semaphore\\SemaphoreFactory::createSemaphore`
 method. Its first argument is an arbitrary string that represents the locked
-resource. Its second argument is the maximum number of process allowed. Then, a
+resource. Its second argument is the maximum number of processes allowed. Then, a
 call to the :method:`Symfony\\Component\\Semaphore\\SemaphoreInterface::acquire`
 method will try to acquire the semaphore::
 
@@ -54,7 +54,7 @@ method will try to acquire the semaphore::
 
     if ($semaphore->acquire()) {
         // The resource "pdf-invoice-generation" is locked.
-        // You can compute and generate invoice safely here.
+        // Here you can safely compute and generate the invoice.
 
         $semaphore->release();
     }

components/string.rst

@@ -36,7 +36,7 @@ However, other languages require thousands of symbols to display their contents.
 They need complex encoding standards such as `Unicode`_ and concepts like
 "character" no longer make sense. Instead, you have to deal with these terms:
 
-* `Code points`_: they are the atomic unit of information. A string is a series
+* `Code points`_: they are the atomic units of information. A string is a series
   of code points. Each code point is a number whose meaning is given by the
   `Unicode`_ standard. For example, the English letter ``A`` is the ``U+0041``
   code point and the Japanese *kana* ``の`` is the ``U+306E`` code point.

components/uid.rst

@@ -331,7 +331,7 @@ type, which converts to/from ULID objects automatically::
         // ...
     }
 
-There's also a Doctrine generator to help autogenerate ULID values for the
+There's also a Doctrine generator to help auto-generate ULID values for the
 entity primary keys::
 
     use Symfony\Bridge\Doctrine\IdGenerator\UlidGenerator;

components/var_dumper.rst

@@ -258,7 +258,7 @@ option. Read more about this and other options in
     finished, press ``Esc.`` to hide the box again.
 
     If you want to use your browser search input, press ``Ctrl. + F`` or
-    ``Cmd. + F`` again while having focus on VarDumper's search input.
+    ``Cmd. + F`` again while focusing on VarDumper's search input.
 
 Using the VarDumper Component in your PHPUnit Test Suite
 --------------------------------------------------------

notifier.rst

@@ -39,7 +39,7 @@ The notifier component supports the following channels:
 
 .. tip::
 
-    Use :doc:`secrets </configuration/secrets>` to securily store your
+    Use :doc:`secrets </configuration/secrets>` to securely store your
     API's tokens.
 
 .. _notifier-sms-channel:
@@ -422,10 +422,10 @@ Symfony provides the following recipients:
 :class:`Symfony\\Component\\Notifier\\Recipient\\NoRecipient`
     This is the default and is useful when there is no need to have
     information about the receiver. For example, the browser channel uses
-    the current requests's :ref:`session flashbag <flash-messages>`;
+    the current requests' :ref:`session flashbag <flash-messages>`;
 
 :class:`Symfony\\Component\\Notifier\\Recipient\\Recipient`
-    This can contain both email address and phonenumber of the user. This
+    This can contain both the email address and the phone number of the user. This
     recipient can be used for all channels (depending on whether they are
     actually set).
 

rate_limiter.rst

@@ -50,7 +50,7 @@ squares).
 
 Its main drawback is that resource usage is not evenly distributed in time and
 it can overload the server at the window edges. In the previous example,
-there are 6 accepted requests between 11:00 and 12:00.
+there were 6 accepted requests between 11:00 and 12:00.
 
 This is more significant with bigger limits. For instance, with 5,000 requests
 per hour, a user could make the 4,999 requests in the last minute of some
@@ -80,15 +80,15 @@ the previous hour and 500 requests this hour. 15 minutes in to the current hour
 (25% of the window) the hit count would be calculated as: 75% * 4,000 + 500 = 3,500.
 At this point in time the user can only do 1,500 more requests.
 
-The math shows that the closer the last window is, the more will the hit count
-of the last window effect the current limit. This will make sure that a user can
-do 5,000 requests per hour but only if they are spread out evenly.
+The math shows that the closer the last window is, the more the hit count
+of the last window will affect the current limit. This will make sure that a user can
+do 5,000 requests per hour but only if they are evenly spread out.
 
 Token Bucket Rate Limiter
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-This technique implements the `token bucket algorithm`_, which defines a
-continuously updating budget of resource usage. It roughly works like this:
+This technique implements the `token bucket algorithm`_, which defines
+continuously updating the budget of resource usage. It roughly works like this:
 
 * A bucket is created with an initial set of tokens;
 * A new token is added to the bucket with a predefined frequency (e.g. every second);
@@ -103,7 +103,7 @@ of 1 token per 15 minutes:
 
     <object data="_images/rate_limiter/token_bucket.svg" type="image/svg+xml"></object>
 
-This algorithm handles more complex back-off algorithm to manage bursts.
+This algorithm handles more complex back-off burst management.
 For instance, it can allow a user to try a password 5 times and then only
 allow 1 every 15 minutes (unless the user waits 75 minutes and they will be
 allowed 5 tries again).

security/custom_authenticator.rst

@@ -4,7 +4,7 @@ How to Write a Custom Authenticator
 Symfony comes with :ref:`many authenticators <security-authenticators>` and
 third party bundles also implement more complex cases like JWT and oAuth
 2.0. However, sometimes you need to implement a custom authentication
-mechanism that doesn't exists yet or you need to customize one. In such
+mechanism that doesn't exist yet or you need to customize one. In such
 cases, you must create and use your own authenticator.
 
 Authenticators should implement the
@@ -133,7 +133,7 @@ The authenticator can be enabled using the ``custom_authenticators`` setting:
 .. versionadded:: 5.2
 
     Starting with Symfony 5.2, the custom authenticator is automatically
-    registered as entry point if it implements ``AuthenticationEntryPointInterface``.
+    registered as an entry point if it implements ``AuthenticationEntryPointInterface``.
 
     Prior to 5.2, you had to configure the entry point separately using the
     ``entry_point`` option. Read :doc:`/security/entry_point` for more
@@ -171,7 +171,7 @@ can define what happens in these cases:
 
     **Caution**: Never use ``$exception->getMessage()`` for ``AuthenticationException``
     instances. This message might contain sensitive information that you
-    don't want to expose publicly. Instead, use ``$exception->getMessageKey()``
+    don't want to be publicly exposed. Instead, use ``$exception->getMessageKey()``
     and ``$exception->getMessageData()`` like shown in the full example
     above. Use :class:`Symfony\\Component\\Security\\Core\\Exception\\CustomUserMessageAuthenticationException`
     if you want to set custom error messages.

security/login_link.rst

@@ -219,7 +219,7 @@ this interface::
     </form>
     {% endblock %}
 
-In this controller, the user is submitting their e-mail address to the
+In this controller, the user is submitting their email address to the
 controller. Based on this property, the correct user is loaded and a login
 link is created using
 :method:`Symfony\\Component\\Security\\Http\\LoginLink\\LoginLinkHandlerInterface::createLoginLink`.
@@ -235,7 +235,7 @@ link is created using
 3) Send the Login Link to the User
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Now the link is created, it needs to be send to the user. Anyone with the
+Now the link is created, it needs to be sent to the user. Anyone with the
 link is able to login as this user, so you need to make sure to send it to
 a known device of them (e.g. using e-mail or SMS).
 

security/passwords.rst

@@ -448,7 +448,7 @@ password should be stored:
 * :ref:`When using Doctrine's entity user provider <upgrade-the-password-doctrine>`
 * :ref:`When using a custom user provider <upgrade-the-password-custom-provider>`
 
-After this, you're done and passwords are always hashed as secure as possible!
+After this, you're done and passwords are always hashed as securely as possible!
 
 .. note::
 
@@ -755,7 +755,7 @@ The Sodium Password Hasher
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 It uses the `Argon2 key derivation function`_. Argon2 support was introduced
-in PHP 7.2 by bundeling the `libsodium`_ extension.
+in PHP 7.2 by bundling the `libsodium`_ extension.
 
 The hashed passwords are ``96`` characters long, but due to the hashing
 requirements saved in the resulting hash this may change in the future, so make

security/remember_me.rst

@@ -135,7 +135,7 @@ The ``remember_me`` firewall defines the following configuration options:
 
 ``service`` (default value: ``null``)
     Defines the ID of the service used to handle the Remember Me feature. It's
-    useful if you need to overwrite the current behavior entirely.
+    useful if you need to overwrite the current behavior.
 
     .. versionadded:: 5.1
 
@@ -204,7 +204,7 @@ users to change their password. You can do this by leveraging a few special
 
 .. tip::
 
-    There is also a ``IS_REMEMBERED`` attribute that grants *only* when the
+    There is also a ``IS_REMEMBERED`` attribute that grants access *only* when the
     user is authenticated via the remember me mechanism.
 
 .. versionadded:: 5.1

security/user_providers.rst

@@ -104,7 +104,7 @@ Using a Custom Query to Load the User
 The entity provider can only query from one *specific* field, specified by
 the ``property`` config key. If you want a bit more control over this - e.g. you
 want to find a user by ``email`` *or* ``username``, you can do that by
-implenting :class:`Symfony\\Bridge\\Doctrine\\Security\\User\\UserLoaderInterface`
+implementing :class:`Symfony\\Bridge\\Doctrine\\Security\\User\\UserLoaderInterface`
 in your :ref:`Doctrine repository <doctrine-queries>` (e.g. ``UserRepository``)::
 
     // src/Repository/UserRepository.php

service_container/autowiring.rst

@@ -611,7 +611,7 @@ you can use the ``@required`` annotation instead.
 
     The ``#[Required]`` attribute was introduced in Symfony 5.2.
 
-Despite property injection has some :ref:`drawbacks <property-injection>`,
+Despite property injection having some :ref:`drawbacks <property-injection>`,
 autowiring with ``#[Required]`` or ``@required`` can also be applied to public
 typed properties:
 

testing.rst

@@ -583,7 +583,7 @@ Logging in Users (Authentication)
 
 When you want to add application tests for protected pages, you have to
 first "login" as a user. Reproducing the actual steps - such as
-submitting a login form - make a test very slow. For this reason, Symfony
+submitting a login form - makes a test very slow. For this reason, Symfony
 provides a ``loginUser()`` method to simulate logging in in your functional
 tests.
 

validation/custom_constraint.rst

@@ -232,8 +232,8 @@ with the necessary ``validator.constraint_validator``. This means you can
 Create a Reusable Set of Constraints
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-In case you need to apply some common set of constraints in different places
-consistently across your application, you can extend the :doc:`Compound constraint </reference/constraints/Compound>`.
+In case you need to consistently apply a common set of constraints
+across your application, you can extend the :doc:`Compound constraint </reference/constraints/Compound>`.
 
 .. versionadded:: 5.1