Fixed formatting issues

book/controller.rst

@@ -638,7 +638,7 @@ and then redirects. The message key (``notice`` in this example) can be anything
 you'll use this key to retrieve the message.
 
 In the template of the next page (or even better, in your base layout template),
-read any flash messages from the session::
+read any flash messages from the session:
 
 .. configuration-block::
 

cookbook/controller/service.rst

@@ -277,8 +277,7 @@ controller:
         in the :class:`Symfony\\Component\\Routing\\Generator\\UrlGeneratorInterface`.
 
 :method:`Symfony\\Bundle\\FrameworkBundle\\Controller\\Controller::getDoctrine` (service: ``doctrine``)
-
-    *Simply inject doctrine instead of fetching it from the container*
+    Simply inject doctrine instead of fetching it from the container.
 
 :method:`Symfony\\Bundle\\FrameworkBundle\\Controller\\Controller::getUser` (service: ``security.context``)
     .. code-block:: php

cookbook/security/custom_provider.rst

@@ -324,9 +324,9 @@ options, the password may be encoded multiple times and encoded to base64.
     before comparing it to your encoded password. If ``getSalt()`` returns
     nothing, then the submitted password is simply encoded using the algorithm
     you specify in ``security.yml``. If a salt *is* specified, then the following
-    value is created and *then* hashed via the algorithm:
+    value is created and *then* hashed via the algorithm::
 
-        ``$password.'{'.$salt.'}';``
+        $password.'{'.$salt.'}'
 
     If your external users have their passwords salted via a different method,
     then you'll need to do a bit more work so that Symfony properly encodes

cookbook/upgrade/_update_dep_errors.rst.inc

@@ -4,6 +4,8 @@ Dependency Errors
 If you get a dependency error, it may simply mean that you need to upgrade
 other Symfony dependencies too. In that case, try the following command:
 
+.. code-block:: bash
+
     $ composer update symfony/symfony --with-dependencies
 
 This updates ``symfony/symfony`` and *all* packages that it depends on, which will

reference/constraints/Callback.rst

@@ -134,110 +134,110 @@ process. Each method can be one of the following formats:
 
 1) **String method name**
 
-    If the name of a method is a simple string (e.g. ``isAuthorValid``),
-    that method will be called on the same object that's being validated
-    and the ``ExecutionContextInterface`` will be the only argument (see
-    the above example).
+   If the name of a method is a simple string (e.g. ``isAuthorValid``),
+   that method will be called on the same object that's being validated
+   and the ``ExecutionContextInterface`` will be the only argument (see
+   the above example).
 
 2) **Static array callback**
 
-    Each method can also be specified as a standard array callback:
-
-    .. configuration-block::
-
-        .. code-block:: php-annotations
-
-            // src/AppBundle/Entity/Author.php
-            use Symfony\Component\Validator\Constraints as Assert;
-
-            /**
-             * @Assert\Callback(methods={
-             *     { "AppBundle\MyStaticValidatorClass", "isAuthorValid" }
-             * })
-             */
-            class Author
-            {
-            }
-
-        .. code-block:: yaml
-
-            # src/AppBundle/Resources/config/validation.yml
-            AppBundle\Entity\Author:
-                constraints:
-                    - Callback:
-                        methods:
-                            -    [AppBundle\MyStaticValidatorClass, isAuthorValid]
-
-        .. code-block:: xml
-
-            <!-- src/AppBundle/Resources/config/validation.xml -->
-            <?xml version="1.0" encoding="UTF-8" ?>
-            <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
-                xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-                xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
-
-                <class name="AppBundle\Entity\Author">
-                    <constraint name="Callback">
-                        <option name="methods">
-                            <value>
-                                <value>AppBundle\MyStaticValidatorClass</value>
-                                <value>isAuthorValid</value>
-                            </value>
-                        </option>
-                    </constraint>
-                </class>
-            </constraint-mapping>
-
-        .. code-block:: php
-
-            // src/AppBundle/Entity/Author.php
-
-            use Symfony\Component\Validator\Mapping\ClassMetadata;
-            use Symfony\Component\Validator\Constraints\Callback;
-
-            class Author
-            {
-                public $name;
-
-                public static function loadValidatorMetadata(ClassMetadata $metadata)
-                {
-                    $metadata->addConstraint(new Callback(array(
-                        'methods' => array(
-                            array(
-                                'AppBundle\MyStaticValidatorClass',
-                                'isAuthorValid',
-                            ),
-                        ),
-                    )));
-                }
-            }
-
-    In this case, the static method ``isAuthorValid`` will be called on
-    the ``AppBundle\MyStaticValidatorClass`` class. It's passed both
-    the original object being validated (e.g. ``Author``) as well as the
-    ``ExecutionContextInterface``::
-
-        namespace AppBundle;
-
-        use Symfony\Component\Validator\ExecutionContextInterface;
-        use AppBundle\Entity\Author;
-
-        class MyStaticValidatorClass
-        {
-            public static function isAuthorValid(
-                Author $author,
-                ExecutionContextInterface $context
-            ) {
-                // ...
-            }
-        }
-
-    .. tip::
-
-        If you specify your ``Callback`` constraint via PHP, then you also
-        have the option to make your callback either a PHP closure or a
-        non-static callback. It is *not* currently possible, however, to
-        specify a :term:`service` as a constraint. To validate using a service,
-        you should :doc:`create a custom validation constraint
-        </cookbook/validation/custom_constraint>` and add that new constraint
-        to your class.
+   Each method can also be specified as a standard array callback:
+
+   .. configuration-block::
+
+       .. code-block:: php-annotations
+
+           // src/AppBundle/Entity/Author.php
+           use Symfony\Component\Validator\Constraints as Assert;
+
+           /**
+            * @Assert\Callback(methods={
+            *     { "AppBundle\MyStaticValidatorClass", "isAuthorValid" }
+            * })
+            */
+           class Author
+           {
+           }
+
+       .. code-block:: yaml
+
+           # src/AppBundle/Resources/config/validation.yml
+           AppBundle\Entity\Author:
+               constraints:
+                   - Callback:
+                       methods:
+                           -    [AppBundle\MyStaticValidatorClass, isAuthorValid]
+
+       .. code-block:: xml
+
+           <!-- src/AppBundle/Resources/config/validation.xml -->
+           <?xml version="1.0" encoding="UTF-8" ?>
+           <constraint-mapping xmlns="http://symfony.com/schema/dic/constraint-mapping"
+               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+               xsi:schemaLocation="http://symfony.com/schema/dic/constraint-mapping http://symfony.com/schema/dic/constraint-mapping/constraint-mapping-1.0.xsd">
+
+               <class name="AppBundle\Entity\Author">
+                   <constraint name="Callback">
+                       <option name="methods">
+                           <value>
+                               <value>AppBundle\MyStaticValidatorClass</value>
+                               <value>isAuthorValid</value>
+                           </value>
+                       </option>
+                   </constraint>
+               </class>
+           </constraint-mapping>
+
+       .. code-block:: php
+
+           // src/AppBundle/Entity/Author.php
+
+           use Symfony\Component\Validator\Mapping\ClassMetadata;
+           use Symfony\Component\Validator\Constraints\Callback;
+
+           class Author
+           {
+               public $name;
+
+               public static function loadValidatorMetadata(ClassMetadata $metadata)
+               {
+                   $metadata->addConstraint(new Callback(array(
+                       'methods' => array(
+                           array(
+                               'AppBundle\MyStaticValidatorClass',
+                               'isAuthorValid',
+                           ),
+                       ),
+                   )));
+               }
+           }
+
+   In this case, the static method ``isAuthorValid`` will be called on
+   the ``AppBundle\MyStaticValidatorClass`` class. It's passed both
+   the original object being validated (e.g. ``Author``) as well as the
+   ``ExecutionContextInterface``::
+
+       namespace AppBundle;
+
+       use Symfony\Component\Validator\ExecutionContextInterface;
+       use AppBundle\Entity\Author;
+
+       class MyStaticValidatorClass
+       {
+           public static function isAuthorValid(
+               Author $author,
+               ExecutionContextInterface $context
+           ) {
+               // ...
+           }
+       }
+
+   .. tip::
+
+       If you specify your ``Callback`` constraint via PHP, then you also
+       have the option to make your callback either a PHP closure or a
+       non-static callback. It is *not* currently possible, however, to
+       specify a :term:`service` as a constraint. To validate using a service,
+       you should :doc:`create a custom validation constraint
+       </cookbook/validation/custom_constraint>` and add that new constraint
+       to your class.