symfony · weaverryan · Nov 23, 2012 · Nov 18, 2012
diff --git a/book/controller.rst b/book/controller.rst
@@ -11,7 +11,7 @@ a serialized JSON array, an image, a redirect, a 404 error or anything else
 you can dream up. The controller contains whatever arbitrary logic *your
 application* needs to render the content of a page.
 
-To see how simple this is, let's look at a Symfony2 controller in action.
+See how simple this is, by looking at a Symfony2 controller in action.
 The following controller would render a page that simply prints ``Hello world!``::
 
     use Symfony\Component\HttpFoundation\Response;
@@ -115,7 +115,7 @@ a controller object. Controllers are also called *actions*.
     will house several controllers/actions (e.g. ``updateAction``, ``deleteAction``,
     etc).
 
-This controller is pretty straightforward, but let's walk through it:
+This controller is pretty straightforward:
 
 * *line 4*: Symfony2 takes advantage of PHP 5.3 namespace functionality to
   namespace the entire controller class. The ``use`` keyword imports the

diff --git a/book/doctrine.rst b/book/doctrine.rst
@@ -4,7 +4,7 @@
 Databases and Doctrine
 ======================
 
-Let's face it, one of the most common and challenging tasks for any application
+One of the most common and challenging tasks for any application
 involves persisting and reading information to and from a database. Fortunately,
 Symfony comes integrated with `Doctrine`_, a library whose sole goal is to
 give you powerful tools to make this easy. In this chapter, you'll learn the
@@ -15,8 +15,8 @@ be.
 
     Doctrine is totally decoupled from Symfony and using it is optional.
     This chapter is all about the Doctrine ORM, which aims to let you map
-    objects to a relational database (such as *MySQL*, *PostgreSQL* or 
-    *Microsoft SQL*). If you prefer to use raw database queries, this is 
+    objects to a relational database (such as *MySQL*, *PostgreSQL* or
+    *Microsoft SQL*). If you prefer to use raw database queries, this is
     easy, and explained in the ":doc:`/cookbook/doctrine/dbal`" cookbook entry.
 
     You can also persist data to `MongoDB`_ using Doctrine ODM library. For
@@ -418,7 +418,7 @@ of the bundle:
     If you're following along with this example, you'll need to create a
     route that points to this action to see it work.
 
-Let's walk through this example:
+Walking through this example:
 
 * **lines 9-12** In this section, you instantiate and work with the ``$product``
   object like any other, normal PHP object.
@@ -956,7 +956,7 @@ table, and ``product.category_id`` column, and new foreign key:
 Saving Related Entities
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-Now, let's see the code in action. Imagine you're inside a controller::
+Now, to see the code in action. Imagine you're inside a controller::
 
     // ...
 
@@ -1371,7 +1371,7 @@ Some notable or interesting tasks include:
 
   .. caution::
 
-      Don't forget to add the ``--no-debug`` switch, because the debug flag is 
+      Don't forget to add the ``--no-debug`` switch, because the debug flag is
       always set to true, even if the environment is set to ``prod``.
 
 * ``doctrine:mapping:import`` - allows Doctrine to introspect an existing

diff --git a/book/forms.rst b/book/forms.rst
@@ -524,7 +524,7 @@ the correct values of a number of field options.
 * ``max_length``: If the field is some sort of text field, then the ``max_length``
   option can be guessed from the validation constraints (if ``MaxLength`` or ``Max``
   is used) or from the Doctrine metadata (via the field's length).
-  
+
 .. note::
 
   These field options are *only* guessed if you're using Symfony to guess
@@ -576,7 +576,7 @@ of code. Of course, you'll usually need much more flexibility when rendering:
             <input type="submit" />
         </form>
 
-Let's take a look at each part:
+Taking a look at each part:
 
 * ``form_enctype(form)`` - If at least one field is a file upload field, this
   renders the obligatory ``enctype="multipart/form-data"``;
@@ -1029,7 +1029,7 @@ In PHP, each form "fragment" is rendered via an individual template file.
 To customize any part of how a form renders, you just need to override the
 existing template by creating a new one.
 
-To understand how this works, let's customize the ``form_row`` fragment and
+To understand how this works, customize the ``form_row`` fragment and
 add a class attribute to the ``div`` element that surrounds each row. To
 do this, create a new template file that will store the new markup:
 
@@ -1259,7 +1259,7 @@ to define form output.
     ever be needed in a single template.
 
     .. caution::
-    
+
         This ``{% form_theme form _self %}`` functionality will *only* work
         if your template extends another. If your template does not, you
         must point ``form_theme`` to a separate template.

diff --git a/book/installation.rst b/book/installation.rst
@@ -75,8 +75,8 @@ something like this:
 
 .. note::
 
-    You can easily override the default directory structure. See 
-    :doc:`/cookbook/configuration/override_dir_structure` for more 
+    You can easily override the default directory structure. See
+    :doc:`/cookbook/configuration/override_dir_structure` for more
     information.
 
 Updating Vendors
@@ -135,9 +135,9 @@ If there are any issues, correct them now before moving on.
 
     **2. Using Acl on a system that does not support chmod +a**
 
-    Some systems don't support ``chmod +a``, but do support another utility 
+    Some systems don't support ``chmod +a``, but do support another utility
     called ``setfacl``. You may need to `enable ACL support`_ on your partition
-    and install setfacl before using it (as is the case with Ubuntu), like 
+    and install setfacl before using it (as is the case with Ubuntu), like
     so:
 
     .. code-block:: bash
@@ -188,7 +188,7 @@ development! Your distribution may contain some sample code - check the
 to learn about what sample code was included with your distribution and how
 you can remove it later.
 
-If you're new to Symfony, join us in the ":doc:`page_creation`", where you'll
+If you're new to Symfony, look at ":doc:`page_creation`", where you'll
 learn how to create pages, change configuration, and do everything else you'll
 need in your new application.
 

diff --git a/book/service_container.rst b/book/service_container.rst
@@ -79,7 +79,7 @@ you need it::
     $mailer = new Mailer('sendmail');
     $mailer->send('ryan@foobar.net', ...);
 
-This is easy enough. The imaginary ``Mailer`` class allows us to configure
+This is easy enough. The imaginary ``Mailer`` class allows you to configure
 the method used to deliver the email messages (e.g. ``sendmail``, ``smtp``, etc).
 But what if you wanted to use the mailer service somewhere else? You certainly
 don't want to repeat the mailer configuration *every* time you need to use
@@ -578,7 +578,7 @@ This approach is fine, but what if you decide later that the ``NewsletterManager
 class needs a second or third constructor argument? What if you decide to
 refactor our code and rename the class? In both cases, you'd need to find every
 place where the ``NewsletterManager`` is instantiated and modify it. Of course,
-the service container gives us a much more appealing option:
+the service container gives you a much more appealing option:
 
 .. configuration-block::
 

diff --git a/components/console/introduction.rst b/components/console/introduction.rst
@@ -23,7 +23,7 @@ You can install the component in many different ways:
 Creating a basic Command
 ------------------------
 
-To make a console command to greet us from the command line, create ``GreetCommand.php``
+To make a console command to greet you from the command line, create ``GreetCommand.php``
 and add the following to it::
 
     namespace Acme\DemoBundle\Command;
@@ -439,4 +439,4 @@ Learn More!
 * :doc:`/components/console/usage`
 * :doc:`/components/console/single_command_tool`
 
-.. _Packagist: https://packagist.org/packages/symfony/console
+.. _Packagist: https://packagist.org/packages/symfony/console
diff --git a/components/dom_crawler.rst b/components/dom_crawler.rst
@@ -179,7 +179,7 @@ Links
 
 To find a link by name (or a clickable image by its ``alt`` attribute), use
 the ``selectLink`` method on an existing crawler. This returns a Crawler
-instance with just the selected link(s). Calling ``link()`` gives us a special
+instance with just the selected link(s). Calling ``link()`` gives you a special
 :class:`Symfony\\Component\\DomCrawler\\Link` object::
 
     $linksCrawler = $crawler->selectLink('Go elsewhere...');
@@ -319,4 +319,4 @@ directly::
     $crawler = $client->submit($form);
 
 .. _`Goutte`:  https://github.com/fabpot/goutte
-.. _Packagist: https://packagist.org/packages/symfony/dom-crawler
+.. _Packagist: https://packagist.org/packages/symfony/dom-crawler
diff --git a/contributing/code/conventions.rst b/contributing/code/conventions.rst
@@ -32,7 +32,7 @@ is a main relation:
 * a ``CookieJar`` has many ``Cookie`` objects;
 
 * a Service ``Container`` has many services and many parameters (as services
-  is the main relation, we use the naming convention for this relation);
+  is the main relation, the naming convention is used for this relation);
 
 * a Console ``Input`` has many arguments and many options. There is no "main"
   relation, and so the naming convention does not apply.
@@ -72,7 +72,7 @@ must be used instead (where ``XXX`` is the name of the related thing):
 
 .. note::
 
-    While "setXXX" and "replaceXXX" are very similar, there is one notable 
-    difference: "setXXX" may replace, or add new elements to the relation. 
+    While "setXXX" and "replaceXXX" are very similar, there is one notable
+    difference: "setXXX" may replace, or add new elements to the relation.
     "replaceXXX", on the other hand, cannot add new elements. If an unrecognized
     key as passed to "replaceXXX" it must throw an exception.
diff --git a/contributing/code/patches.rst b/contributing/code/patches.rst
@@ -29,7 +29,7 @@ Set up your user information with your real name and a working email address:
 
 .. tip::
 
-    If you are new to Git, we highly recommend you to read the excellent and
+    If you are new to Git, you are highly recommended to read the excellent and
     free `ProGit`_ book.
 
 .. tip::

diff --git a/contributing/documentation/overview.rst b/contributing/documentation/overview.rst
@@ -26,12 +26,12 @@ then clone your fork:
     $ git clone git://github.com/YOURUSERNAME/symfony-docs.git
 
 Consistent with Symfony's source code, the documentation repository is split into
-three branches: ``2.0`` for the current Symfony 2.0.x release, ``2.1`` for the 
-current Symfony 2.1.x release and ``master`` as the development branch for 
+three branches: ``2.0`` for the current Symfony 2.0.x release, ``2.1`` for the
+current Symfony 2.1.x release and ``master`` as the development branch for
 upcoming releases.
 
 Unless you're documenting a feature that's new to Symfony 2.1, your changes
-should always be based on the 2.0 branch instead of the master branch. To do 
+should always be based on the 2.0 branch instead of the master branch. To do
 this checkout the 2.0 branch before the next step:
 
 .. code-block:: bash
@@ -52,7 +52,7 @@ the ``symfony-docs`` ``master`` branch.
 .. image:: /images/docs-pull-request.png
    :align: center
 
-If you have made your changes based on the 2.0 branch then you need to change 
+If you have made your changes based on the 2.0 branch then you need to change
 the base branch to be 2.0 on the preview page:
 
 .. image:: /images/docs-pull-request-change-base.png
@@ -61,7 +61,7 @@ the base branch to be 2.0 on the preview page:
 .. note::
 
   All changes made to the 2.0 branch will be merged into 2.1 which in turn will be
-  merged into the master branch for the next release on a weekly basis. 
+  merged into the master branch for the next release on a weekly basis.
 
 GitHub covers the topic of `pull requests`_ in detail.
 
@@ -73,9 +73,9 @@ GitHub covers the topic of `pull requests`_ in detail.
 .. tip::
 
     Please be patient. It can take from 15 minutes to several days for your changes
-    to appear on the symfony.com website after the documentation team merges your 
-    pull request. You can check if your changes have introduced some markup issues 
-    by going to the `Documentation Build Errors`_ page (it is updated each French 
+    to appear on the symfony.com website after the documentation team merges your
+    pull request. You can check if your changes have introduced some markup issues
+    by going to the `Documentation Build Errors`_ page (it is updated each French
     night at 3AM when the server rebuilds the documentation).
 
 Standards
@@ -88,19 +88,19 @@ look and feel familiar, you should follow these rules:
   as well as the `Twig Coding Standards`_;
 * Each line should break approximately after the first word that crosses the
   72nd character (so most lines end up being 72-78 lines);
-* When we fold one or more lines of code, we place ``...`` in a comment at the point
+* When you fold one or more lines of code, place ``...`` in a comment at the point
   of the fold. These comments are: ``// ...`` (php), ``# ...`` (yaml/bash), ``{# ... #}``
   (twig), ``<!-- ... -->`` (xml/html), ``; ...`` (ini), ``...`` (text);
-* When we fold a part of a line, e.g. a variable value, we put ``...`` (without comment)
+* When you fold a part of a line, e.g. a variable value, put ``...`` (without comment)
   at the place of the fold;
 * Description of the folded code: (optional)
-  If we fold several lines: the description of the fold can be placed after the ``...``
-  If we fold only part of a line: the description can be placed before the line;
+  If you fold several lines: the description of the fold can be placed after the ``...``
+  If you fold only part of a line: the description can be placed before the line;
 * If useful, a ``codeblock`` should begin with a comment containing the filename
   of the file in the code block. Don't place a blank line after this comment,
   unless the next line is also a comment;
 * You should put a ``$`` in front of every bash line;
-* We prefer the ``::`` shorthand over ``.. code-block:: php`` to begin a PHP
+* The ``::`` shorthand is preferred over ``.. code-block:: php`` to begin a PHP
   code block.
 
 An example::

diff --git a/cookbook/console/console_command.rst b/cookbook/console/console_command.rst
@@ -15,7 +15,7 @@ To make the console commands available automatically with Symfony2, create a
 ``Command`` directory inside your bundle and create a php file suffixed with
 ``Command.php`` for each command that you want to provide. For example, if you
 want to extend the ``AcmeDemoBundle`` (available in the Symfony Standard
-Edition) to greet us from the command line, create ``GreetCommand.php`` and
+Edition) to greet you from the command line, create ``GreetCommand.php`` and
 add the following to it::
 
     // src/Acme/DemoBundle/Command/GreetCommand.php
@@ -93,9 +93,9 @@ should be used instead of :class:`Symfony\\Component\\Console\\Application`::
 Getting Services from the Service Container
 -------------------------------------------
 
-By using :class:`Symfony\\Bundle\\FrameworkBundle\\Command\\ContainerAwareCommand` 
-as the base class for the command (instead of the more basic 
-:class:`Symfony\\Component\\Console\\Command\\Command`), you have access to the 
+By using :class:`Symfony\\Bundle\\FrameworkBundle\\Command\\ContainerAwareCommand`
+as the base class for the command (instead of the more basic
+:class:`Symfony\\Component\\Console\\Command\\Command`), you have access to the
 service container. In other words, you have access to any configured service.
 For example, you could easily extend the task to be translatable::
 

diff --git a/cookbook/event_dispatcher/before_after_filters.rst b/cookbook/event_dispatcher/before_after_filters.rst
@@ -180,7 +180,7 @@ your listener to be called just before any controller is executed.
 With this configuration, your ``TokenListener`` ``onKernelController`` method
 will be executed on each request. If the controller that is about to be executed
 implements ``TokenAuthenticatedController``, token authentication is
-applied. This lets us have a "before" filter on any controller that you
+applied. This lets you have a "before" filter on any controller that you
 want.
 
 After filters with the ``kernel.response`` Event

diff --git a/cookbook/form/dynamic_form_generation.rst b/cookbook/form/dynamic_form_generation.rst
@@ -120,7 +120,7 @@ might look like the following::
             // During form creation setData() is called with null as an argument
             // by the FormBuilder constructor. You're only concerned with when
             // setData is called with an actual Entity object in it (whether new
-            // or fetched with Doctrine). This if statement lets us skip right
+            // or fetched with Doctrine). This if statement lets you skip right
             // over the null condition.
             if (null === $data) {
                 return;

diff --git a/cookbook/service_container/event_listener.rst b/cookbook/service_container/event_listener.rst
@@ -11,7 +11,7 @@ component and can be viewed in the :class:`Symfony\\Component\\HttpKernel\\Kerne
 To hook into an event and add your own custom logic, you have to  create
 a service that will act as an event listener on that event. In this entry,
 you will create a service that will act as an Exception Listener, allowing
-us to modify how exceptions are shown by  our application. The ``KernelEvents::EXCEPTION``
+you to modify how exceptions are shown by  our application. The ``KernelEvents::EXCEPTION``
 event is just one of the core kernel events::
 
     // src/Acme/DemoBundle/Listener/AcmeExceptionListener.php

diff --git a/quick_tour/the_architecture.rst b/quick_tour/the_architecture.rst
@@ -147,7 +147,7 @@ a single ``Bundle`` class that describes it::
         return $bundles;
     }
 
-In addition to the ``AcmeDemoBundle`` that we have already talked about, notice
+In addition to the ``AcmeDemoBundle`` that was already talked about, notice
 that the kernel also enables other bundles such as the ``FrameworkBundle``,
 ``DoctrineBundle``, ``SwiftmailerBundle``, and ``AsseticBundle`` bundle.
 They are all part of the core framework.
@@ -297,8 +297,8 @@ If you follow these conventions, then you can use :doc:`bundle inheritance</cook
 to "override" files, controllers or templates. For example, you can create
 a bundle - ``AcmeNewBundle`` - and specify that it overrides ``AcmeDemoBundle``.
 When Symfony loads the ``AcmeDemoBundle:Welcome:index`` controller, it will
-first look for the ``WelcomeController`` class in ``AcmeNewBundle`` and, if 
-it doesn't exist, then look inside ``AcmeDemoBundle``. This means that one bundle 
+first look for the ``WelcomeController`` class in ``AcmeNewBundle`` and, if
+it doesn't exist, then look inside ``AcmeDemoBundle``. This means that one bundle
 can override almost any part of another bundle!
 
 Do you understand now why Symfony2 is so flexible? Share your bundles between

diff --git a/quick_tour/the_big_picture.rst b/quick_tour/the_big_picture.rst
@@ -20,13 +20,13 @@ First, check that you have installed and configured a Web server (such as
 Apache) with PHP 5.3.2 or higher.
 
 .. tip::
-   
+
     If you have PHP 5.4, you could use the built-in web server. The built-in
     server should be used only for development purpose, but it can help you
     to start your project quickly and easily.
 
     Just use this command to launch the server:
-    
+
     .. code-block:: bash
 
         $ php -S localhost:80 -t /path/to/www
@@ -223,7 +223,7 @@ the ``Acme\DemoBundle\Controller\WelcomeController`` class::
 
 .. tip::
 
-    You could have used the full class and method name - 
+    You could have used the full class and method name -
     ``Acme\DemoBundle\Controller\WelcomeController::indexAction`` - for the
     ``_controller`` value. But if you follow some simple conventions, the
     logical name is shorter and allows for more flexibility.
@@ -347,12 +347,12 @@ templates work in Symfony2.
 Bundles
 ~~~~~~~
 
-You might have wondered why the :term:`bundle` word is used in many names we
+You might have wondered why the :term:`bundle` word is used in many names you
 have seen so far. All the code you write for your application is organized in
 bundles. In Symfony2 speak, a bundle is a structured set of files (PHP files,
 stylesheets, JavaScripts, images, ...) that implements a single feature (a
 blog, a forum, ...) and which can be easily shared with other developers. As
-of now, we have manipulated one bundle, ``AcmeDemoBundle``. You will learn
+of now, you have manipulated one bundle, ``AcmeDemoBundle``. You will learn
 more about bundles in the last chapter of this tutorial.
 
 .. _quick-tour-big-picture-environments: