From 2c680a3b013ee9bc2bcab508e225ac0d9c22ffe6 Mon Sep 17 00:00:00 2001
From: David Buchmann <david.buchmann@liip.ch>
Date: Sun, 20 Aug 2017 16:26:06 +0200
Subject: [PATCH] add book into bundles doc

---
 book/handling_multilang.rst                   | 349 ------------
 book/index.rst                                |  15 -
 book/installation.rst                         | 294 ----------
 book/map.rst.inc                              |   6 -
 book/routing.rst                              | 538 ------------------
 book/simplecms.rst                            | 164 ------
 book/static_content.rst                       |  81 ---
 book/structuring_content.rst                  | 175 ------
 bundles/content/introduction.rst              |   3 -
 bundles/core/publish_workflow.rst             |  12 +-
 bundles/phpcr_odm/configuration.rst           |   4 +-
 bundles/phpcr_odm/index.rst                   |   1 +
 bundles/phpcr_odm/introduction.rst            |  11 +
 .../phpcr_odm/models.rst                      |  37 +-
 bundles/phpcr_odm/multilang.rst               |   7 +
 bundles/routing/dynamic.rst                   |   5 +-
 bundles/routing/introduction.rst              |   8 +-
 bundles/simple_cms/introduction.rst           |   3 -
 cookbook/editions/cmf_core.rst                |  10 +-
 cookbook/editions/cmf_sandbox.rst             |  12 +-
 cookbook/map.rst.inc                          |   1 -
 index.rst                                     |  17 -
 quick_tour/the_big_picture.rst                |  19 +-
 quick_tour/the_model.rst                      |   2 +-
 quick_tour/the_third_party_bundles.rst        |  37 +-
 tutorial/sonata-admin.rst                     |   5 -
 26 files changed, 92 insertions(+), 1724 deletions(-)
 delete mode 100644 book/handling_multilang.rst
 delete mode 100644 book/index.rst
 delete mode 100644 book/installation.rst
 delete mode 100644 book/map.rst.inc
 delete mode 100644 book/routing.rst
 delete mode 100644 book/simplecms.rst
 delete mode 100644 book/static_content.rst
 delete mode 100644 book/structuring_content.rst
 rename book/database_layer.rst => bundles/phpcr_odm/models.rst (91%)

diff --git a/book/handling_multilang.rst b/book/handling_multilang.rst
deleted file mode 100644
index 8d6c8dd3..00000000
--- a/book/handling_multilang.rst
+++ /dev/null
@@ -1,349 +0,0 @@
-.. index::
-    single: Multi Language; Book
-
-Handling Multi-Language Documents
-=================================
-
-The default storage layer of the CMF, PHPCR-ODM, can handle translations
-transparently.
-
-.. tip::
-
-   This chapter assumes you already have an idea how to interact with
-   PHPCR-ODM, which was introduced in the :doc:`Database chapter <database_layer>`.
-
-.. caution::
-
-    You also need the ``intl`` php extension installed and enabled (otherwise
-    composer will tell you it can't find ``ext-intl``). If you get issues that some
-    locales can not be loaded, have a look at `this discussion about ICU`_.
-
-Initial Language Choice: Lunetics LocaleBundle
-----------------------------------------------
-
-The CMF recommends to rely on the `LuneticsLocaleBundle`_
-to handle requests to ``/`` on your website. This bundle provides the tools
-to select the best locale for the user based on various criteria.
-
-When you configure ``lunetics_locale``, it is recommended to use a parameter
-for the locales, as you need to configure the locales for other bundles
-(e.g. the CoreBundle) too.
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        lunetics_locale:
-            allowed_locales: "%locales%"
-
-    .. code-block:: xml
-
-        <?xml version="1.0" charset="UTF-8" ?>
-        <container xmlns="http://symfony.com/schema/dic/services">
-
-            <config xmlns="http://example.org/schema/dic/lunetics_locale">
-                <allowed-locales>%locales%</allowed-locales>
-            </config>
-        </container>
-
-    .. code-block:: php
-
-        $container->loadFromExtension('lunetics_locale', array(
-            'allowed_locales' => '%locales%',
-        ));
-
-Configuring Available Locales
------------------------------
-
-The CoreBundle needs to be configure with the available locales. If it is
-not configured with locales, it registries a listener that removes all
-translation mapping from PHPCR-ODM documents.
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        cmf_core:
-            multilang:
-                locales: "%locales%"
-
-    .. code-block:: xml
-
-        <?xml version="1.0" charset="UTF-8" ?>
-        <container xmlns="http://symfony.com/schema/dic/services">
-
-            <config xmlns="http://cmf.symfony.com/schema/dic/core">
-                <multilang>%locales%</multilang>
-            </config>
-        </container>
-
-    .. code-block:: php
-
-        $container->loadFromExtension('cmf_core', array(
-            'multilang' => array(
-                'locales' => '%locales%',
-            ),
-        ));
-
-PHPCR-ODM multi-language Documents
-----------------------------------
-
-You can mark any properties as being translatable and have the document
-manager store and load the correct language for you. Note that translation
-always happens on a document level, not on the individual translatable fields.
-
-.. code-block:: php
-
-    <?php
-
-    // src/Acme/DemoBundle/Document/MyPersistentClass.php
-
-    use Doctrine\ODM\PHPCR\Mapping\Annotations as PHPCR;
-
-    /**
-     * @PHPCR\Document(translator="attribute")
-     */
-    class MyPersistentClass
-    {
-        /**
-         * Translated property
-         * @PHPCR\Field(type="string", translated=true)
-         */
-        private $topic;
-
-        // ...
-    }
-
-.. seealso::
-
-    Read more about multi-language documents in the
-    `PHPCR-ODM documentation on multi-language`_ and see
-    :doc:`../bundles/phpcr_odm/multilang` for information how to configure
-    PHPCR-ODM correctly.
-
-The default documents provided by the CMF bundles are translated documents.
-The CoreBundle removes the translation mapping if ``multilang`` is not
-configured.
-
-The routes are handled differently, as you can read in the next section.
-
-Routing
--------
-
-The ``DynamicRouter`` uses a route source to get routes that could match a
-request. The concept of the default PHPCR-ODM source is to map the request URL
-onto an id, which in PHPCR terms is the repository path to a node. This allows
-for a very efficient lookup without needing a full search over the repository.
-But a PHPCR node has exactly one path, therefore you need a separate route
-document per locale. The cool thing with this is that you can localize
-the URL for each language. Simply create one route document per locale.
-
-As all routes point to the same content, the route generator can handle
-picking the correct route for you when you generate the route from the
-content. See also
-":ref:`ContentAwareGenerator and Locales <component-route-generator-and-locales>`".
-
-.. _book_handling-multilang_sonata-admin:
-
-Sonata PHPCR-ODM Admin
-----------------------
-
-.. note::
-
-    Using sonata admin is one way to make your content editable. A book
-    chapter on sonata admin is planned. Meanwhile, read
-    :doc:`Sonata Admin <../tutorial/sonata-admin>` in the "Creating a CMS"
-    tutorial.
-
-The first step is to configure sonata admin. You should place the
-LuneticsLocaleBundle language switcher in the ``topnav`` bar.  To do this,
-configure the template for the ``user_block``:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/config.yml
-        sonata_admin:
-            # ...
-            templates:
-                    user_block: AcmeCoreBundle:Admin:admin_topnav.html.twig
-
-    .. code-block:: xml
-
-        <!-- app/config/config.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-        <container xmlns="http://symfony.com/schema/dic/services">
-            <config xmlns="http://sonata-project.org/schema/dic/admin">
-                <template user-block="AcmeCoreBundle:Admin:admin_topnav.html.twig"/>
-            </config>
-        </container>
-
-
-    .. code-block:: php
-
-        // app/config/config.php
-        $container->loadFromExtension('sonata_admin', array(
-            'templates' => array(
-                'user_block' => 'AcmeCoreBundle:Admin:admin_topnav.html.twig',
-            ),
-        ));
-
-And the template looks like this:
-
-.. code-block:: jinja
-
-    {# src/Acme/CoreBundle/Resources/views/Admin/admin_topnav.html.twig #}
-    {% extends 'SonataAdminBundle:Core:user_block.html.twig' %}
-
-    {% block user_block %}
-        {{ locale_switcher(null, null, 'AcmeCoreBundle:Admin:switcher_links.html.twig') }}
-        {{ parent() }}
-    {% endblock %}
-
-You need to tell the ``locale_switcher`` to use a custom template to display
-the links, which looks like this:
-
-.. code-block:: jinja
-
-    {# src/Acme/CoreBundle/Resources/views/Admin/switcher_links.html.twig #}
-    Switch to :
-    {% for locale in locales %}
-        {% if loop.index > 1 %} | {% endif %}<a href="{{ locale.link }}" title="{{ locale.locale_target_language }}">{{ locale.locale_target_language }}</a>
-    {% endfor %}
-
-Now what is left to do is to update the sonata routes to become locale aware:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/routing.yml
-
-        admin_dashboard:
-            pattern: /{_locale}/admin/
-            defaults:
-                _controller: FrameworkBundle:Redirect:redirect
-                route: sonata_admin_dashboard
-                permanent: true # this for 301
-
-        admin:
-            resource: '@SonataAdminBundle/Resources/config/routing/sonata_admin.xml'
-            prefix: /{_locale}/admin
-
-        sonata_admin:
-            resource: .
-            type: sonata_admin
-            prefix: /{_locale}/admin
-
-        # redirect routes for the non-locale routes
-        admin_without_locale:
-            pattern: /admin
-            defaults:
-                _controller: FrameworkBundle:Redirect:redirect
-                route: sonata_admin_dashboard
-                permanent: true # this for 301
-
-        admin_dashboard_without_locale:
-            pattern: /admin/dashboard
-            defaults:
-                _controller: FrameworkBundle:Redirect:redirect
-                route: sonata_admin_dashboard
-                permanent: true
-
-    .. code-block:: xml
-
-        <?xml version="1.0" encoding="UTF-8" ?>
-        <routes xmlns="http://symfony.com/schema/dic/routing">
-
-            <route id="admin_dashboard" pattern="/{_locale}/admin/">
-                <default key="_controller">FrameworkBundle:Redirect:redirect</default>
-                <default key="route">sonata_admin_dashboard</default>
-                <default key="permanent">true</default>
-            </route>
-
-            <import resource="@SonataAdminBundle/Resources/config/routing/sonata_admin.xml"
-                    prefix="/{_locale}/admin"
-            />
-
-            <import resource="." type="sonata_admin" prefix="/{_locale}/admin"/>
-
-            <!-- redirect routes for the non-locale routes -->
-            <route id="admin_without_locale" pattern="/admin">
-                <default key="_controller">FrameworkBundle:Redirect:redirect</default>
-                <default key="route">sonata_admin_dashboard</default>
-                <default key="permanent">true</default>
-            </route>
-
-            <route id="admin_dashboard_without_locale" pattern="/admin/dashboard">
-                <default key="_controller">FrameworkBundle:Redirect:redirect</default>
-                <default key="route">sonata_admin_dashboard</default>
-                <default key="permanent">true</default>
-            </route>
-        </routes>
-
-    .. code-block:: php
-
-        // app/config/routing.php
-        $collection = new RouteCollection();
-
-        $collection->add('admin_dashboard', new Route('/{_locale}/admin/', array(
-            '_controller' => 'FrameworkBundle:Redirect:redirect',
-            'route' => 'sonata_admin_dashboard',
-            'permanent' => true,
-        )));
-
-        $sonata = $loader->import('@SonataAdminBundle/Resources/config/routing/sonata_admin.xml');
-        $sonata->addPrefix('/{_locale}/admin');
-        $collection->addCollection($sonata);
-
-        $sonata = $loader->import('.', 'sonata_admin');
-        $sonata->addPrefix('/{_locale}/admin');
-        $collection->addCollection($sonata);
-
-        $collection->add('admin_without_locale', new Route('/admin', array(
-            '_controller' => 'FrameworkBundle:Redirect:redirect',
-            'route' => 'sonata_admin_dashboard',
-            'permanent' => true,
-        )));
-
-        $collection->add('admin_dashboard_without_locale', new Route('/admin/dashboard', array(
-            '_controller' => 'FrameworkBundle:Redirect:redirect',
-            'route' => 'sonata_admin_dashboard',
-            'permanent' => true,
-        )));
-
-        return $collection
-
-Now reload the admin dashboard. The URL should be prefixed with the
-default locale, for example ``/de/admin/dashboard``. When clicking on the
-language switcher, the page reloads and displays the correct content for the
-requested language.
-
-If your documents implement the TranslatableInterface, use the
-SonataTranslationBundle_ to enable multi-language editing in the admin backend.
-
-Frontend Editing and multi-language
------------------------------------
-
-When using the CreateBundle, you do not need to do anything at all to get
-multi-language support. PHPCR-ODM will deliver the document in the requested
-language, and the callback URL is generated in the request locale, leading to
-save the edited document in the same language as it was loaded.
-
-.. note::
-
-    If a translation is missing, language fallback kicks in, both when viewing
-    the page but also when saving the changes, so you always update the
-    current locale.
-
-    It would make sense to offer the user the choice whether they want to
-    create a new translation or update the existing one. There is this
-    `issue`_ in the CreateBundle issue tracker.
-
-.. _`LuneticsLocaleBundle`: https://github.com/lunetics/LocaleBundle/
-.. _`this discussion about ICU`: https://github.com/symfony/symfony/issues/5279#issuecomment-11710480
-.. _`cmf-sandbox config.yml file`: https://github.com/symfony-cmf/cmf-sandbox/blob/master/app/config/config.yml
-.. _`PHPCR-ODM documentation on multi-language`: http://docs.doctrine-project.org/projects/doctrine-phpcr-odm/en/latest/reference/multilang.html
-.. _`issue`: https://github.com/symfony-cmf/create-bundle/issues/39
-.. _SonataTranslationBundle: https://packagist.org/packages/sonata-project/translation-bundle
diff --git a/book/index.rst b/book/index.rst
deleted file mode 100644
index 47d2c975..00000000
--- a/book/index.rst
+++ /dev/null
@@ -1,15 +0,0 @@
-The Book
-========
-
-.. toctree::
-    :hidden:
-
-    database_layer
-    installation
-    routing
-    simplecms
-    static_content
-    structuring_content
-    handling_multilang
-
-.. include:: map.rst.inc
diff --git a/book/installation.rst b/book/installation.rst
deleted file mode 100644
index 0847a2ac..00000000
--- a/book/installation.rst
+++ /dev/null
@@ -1,294 +0,0 @@
-.. index::
-    single: Installation; Getting Started
-    single: Standard Edition
-
-Installing the Standard Edition
-===============================
-
-The Symfony CMF Standard Edition (SE) is a distribution based on all the
-main components needed for most common use cases.
-
-The goal of this tutorial is to install the CMF bundles, with the minimum
-necessary configuration and some very simple examples, into a working Symfony2
-application.
-
-After that, you get a quick introduction of the bundles you have installed.
-This can be used to familiarize yourself with the CMF or as a starting point
-for a new custom application.
-
-This tutorial is aimed at people who want to get started with a project based
-on the Symfony CMF. There are two alternate articles in the cookbook you might
-want to look at, depending on what you need:
-
-* :doc:`../cookbook/editions/cmf_core` - a guide for adding the CMF to a standard
-  Symfony project.
-* :doc:`../cookbook/editions/cmf_sandbox` for instructions on how to install a
-  demonstration sandbox. The sandbox contains many examples of what you can do
-  with the CMF.
-
-Preconditions
--------------
-
-As Symfony CMF is based on Symfony2, you should make sure you meet the
-`Requirements for running Symfony2`_. Additionally, you need to have `SQLite`_
-PDO extension (``pdo_sqlite``) installed, since it is used as the default
-storage medium.
-
-.. note::
-
-    By default, Symfony CMF uses Jackalope + Doctrine DBAL and SQLite as the
-    underlying DB. However, Symfony CMF is storage agnostic, which means you
-    can use one of several available data storage mechanisms without having to
-    rewrite your code. For more information on the different available
-    mechanisms and how to install and configure them, refer to
-    :doc:`../bundles/phpcr_odm/introduction`.
-
-Installation
-------------
-
-You can install the Standard Edition in 2 ways:
-
-1) Composer
-~~~~~~~~~~~
-
-The easiest way to install Symfony CMF is is using `Composer`_. Get it using
-
-.. code-block:: bash
-
-    $ curl -sS https://getcomposer.org/installer | php
-    $ sudo mv composer.phar /usr/local/bin/composer
-
-and then get the Symfony CMF code with it (this may take a while):
-
-.. code-block:: bash
-
-    $ composer create-project symfony-cmf/standard-edition <path-to-install> "~1.2"
-    $ cd <path-to-install>
-
-.. note::
-
-    The path ``<path-to-install>`` should either be inside your web server doc
-    root or you need to configure a virtual host for ``<path-to-install>``.
-
-This will clone the Standard Edition and install all the dependencies and run
-some initial commands. These commands require write permissions to the
-``var/cache`` and ``var/logs`` directory. In case the final commands end up
-giving permissions errors, please follow the `guidelines in the Symfony Book`_
-to configure the permissions and then run the ``install`` command:
-
-.. code-block:: bash
-
-    $ composer install
-
-2) GIT
-~~~~~~
-
-You can also install the Standard Edition using GIT. Just clone the repository
-from github:
-
-.. code-block:: bash
-
-    $ git clone git://github.com/symfony-cmf/standard-edition.git <path-to-install>
-    $ cd <path-to-install>
-
-You still need Composer to get the dependencies. To get the correct
-dependencies, use the ``install`` command:
-
-.. code-block:: bash
-
-    $ composer install
-
-To try out things, you can accept the default values for all questions you are
-asked about the parameters.yml. Revisit that file later when you know more
-about Jackalope.
-
-Setup
------
-
-You are almost there. A few more steps need to be done to be ready.
-
-Set up the Database
-~~~~~~~~~~~~~~~~~~~
-
-The next step is to set up the database. If you want to use SQLite as your
-database backend just go ahead and run the following:
-
-.. code-block:: bash
-
-    $ php bin/console doctrine:database:create
-    $ php bin/console doctrine:phpcr:init:dbal --force
-    $ php bin/console doctrine:phpcr:repository:init
-    $ php bin/console doctrine:phpcr:fixtures:load
-
-The first command will create a file called ``app.sqlite`` inside your app
-folder, containing the database content. The two commands after it will setup
-PHPCR and the final command will load some fixtures, so you can access the
-Standard Edition using a web server.
-
-Preparing Assetic
-~~~~~~~~~~~~~~~~~
-
-To use the frontend editing in ``prod`` environment, you need to tell Assetic
-to dump the assets to the filesystem:
-
-.. code-block:: bash
-
-    $ php bin/console --env=prod assetic:dump
-
-Configure a Webserver
-~~~~~~~~~~~~~~~~~~~~~
-
-The project is now ready to be served by your web server. If you have PHP 5.4
-installed you can alternatively use the PHP internal web server:
-
-.. code-block:: bash
-
-    $ php bin/console server:run
-
-And then access the CMF via:
-
-.. code-block:: text
-
-    http://localhost:8000
-
-If you run an Apache installation as described in the `Symfony cookbook article on setup`_,
-your URL will look like this:
-
-.. code-block:: text
-
-    http://localhost/app_dev.php
-
-.. note::
-
-    Adding the ``app_dev.php`` to the url in your browser is important to actually
-    see the test page. Because the AcmeDemoBundle is only configured to work with the
-    Development Environment. (If you have a look at ``AppKernel.php`` you can easily
-    spot why)
-
-.. sidebar:: Using Other Database Backends
-
-    If you prefer to use another database backend, for example MySQL, run the
-    configurator (point your browser to ``http://localhost:8000/config.php``)
-    or set your database connection parameters in ``app/config/parameters.yml``.
-    Make sure you leave the ``database_path`` property at ``null`` in order to
-    use another driver than SQLite. Leaving the field blank in the
-    web-configurator will set it to ``null``. You also need to uncomment lines
-    in ``app/config/config.yml`` in section ``doctrine.dbal``.
-
-.. note::
-
-    The proper term to use for the default database of the CMF is
-    *content repository*. The idea behind this name is essentially to describe a
-    specialized database created specifically for content management systems.
-    The acronym *PHPCR* actually stands for *PHP content repository*. But as
-    mentioned before, the CMF is storage agnostic so its possible to combine
-    the CMF with other storage mechanism, like Doctrine ORM, Propel etc.
-
-Overview
---------
-
-This section will help you understand the basic parts of Symfony CMF Standard
-Edition (SE) and how they work together to provide the default pages you can
-see when browsing the Symfony CMF SE installation.
-
-It assumes you have already installed Symfony CMF SE and have carefully read
-`the Symfony2 book`_.
-
-AcmeMainBundle and SimpleCmsBundle
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Symfony CMF SE comes with a default AcmeDemoBundle to help you get started,
-similar to the AcmeDemoBundle provided by Symfony2 SE. This gives you some demo
-pages viewable in your browser.
-
-.. sidebar:: Where are the Controllers?
-
-    AcmeDemoBundle doesn't include controllers or configuration files as you
-    might expect. It contains little more than a Twig file and `Fixtures`_
-    data that was loaded into your database during installation. The biggest
-    chunk of code is the ``UnitBlock`` that provides a document for an example
-    block.
-
-    The controller logic is actually provided by the relevant CMF bundles,
-    as described below.
-
-There are several bundles working together in order to turn the fixture data
-into a browsable website. The overall, simplified process is:
-
-* When a request is received, the :doc:`Symfony CMF Routing's Dynamic Router <routing>`
-  is used to handle the incoming request;
-* The Dynamic Router is able to match the requested URL to a ``Page`` document
-  provided by SimpleCmsBundle and stored inside the database;
-* The retrieved document information is used to determine which controller to
-  pass it on to, and which template to use;
-* As configured, the retrieved document is passed to ``ContentController``
-  provided by the ContentBundle, which render document into ``layout.html.twig``
-  of the AcmeMainBundle.
-
-Again, this is simplified view of a very simple CMS built on top of Symfony
-CMF. To fully understand all the possibilities of the CMF, continue reading
-this Book section.
-
-If you want to review the contents of the PHPCR database you can use the
-following commands:
-
-.. code-block:: bash
-
-    $ php bin/console doctrine:phpcr:node:dump
-    $ php bin/console doctrine:phpcr:node:dump --props
-    $ php bin/console doctrine:phpcr:node:dump /path/to/node
-
-The above examples respectively show a summary, a detailed view, and a summary
-of a node and all its children (instead of starting at the root node).
-
-Don't forget to look at the ``--help`` output for more possibilities:
-
-.. code-block:: bash
-
-    $ php bin/console doctrine:phpcr:node:dump --help
-
-Adding new pages
-~~~~~~~~~~~~~~~~
-
-Symfony CMF SE does not provide any admin tools to create new pages. If you
-are interested in adding an admin UI one solution can be found in
-:doc:`../tutorial/sonata-admin`. However, if all you want
-is a simple way to add new pages that you can then edit via the in-line
-editing, then you can use the SimpleCmsBundle ``page`` migrator. For example,
-to add a page called "Testing", creating a file called
-``app/Resources/data/pages/test.yml`` with the following contents:
-
-.. code-block:: yaml
-
-    label: "Testing"
-    title: "Testing"
-    body: |
-        <p>Lorem ipsum dolor sit amet, consectetur adipiscing elit.</p>
-        <p>Morbi eleifend, ipsum eget facilisis lacinia, lorem dui venenatis quam, at vulputate purus erat sit amet elit.</p>
-
-The contents of this file can be loaded into the PHPCR database by calling:
-
-.. code-block:: bash
-
-    $ php bin/console doctrine:phpcr:migrator:migrate page --identifier=/cms/simple/test
-
-Note that the above identifier is mapped to
-``app/Resources/data/pages/test.yml`` by stripping off the ``basepath``
-configuration of the SimpleCmsBundle (which defaults to ``/cms/simple``).
-
-Therefore if you want to define a child page ``foo`` for ``/cms/simple/test``
-you would need to create a file ``app/Resources/data/pages/test/foo.yml``
-and then run the following command:
-
-.. code-block:: bash
-
-    $ php bin/console doctrine:phpcr:migrator:migrate page --identifier=/cms/simple/test/foo
-
-.. _`cmf.liip.ch`: http://cmf.liip.ch
-.. _`Requirements for running Symfony2`: https://symfony.com/doc/current/reference/requirements.html
-.. _`SQLite`: http://www.sqlite.org/
-.. _`Composer`: https://getcomposer.org/
-.. _`guidelines in the symfony book`: https://symfony.com/doc/current/book/installation.html#book-installation-permissions
-.. _`the Symfony2 book`: https://symfony.com/doc/current/book/index.html
-.. _`Fixtures`: https://symfony.com/doc/current/bundles/DoctrineFixturesBundle/index.html
-.. _`Symfony cookbook article on setup`: https://symfony.com/doc/current/cookbook/configuration/web_server_configuration.html
diff --git a/book/map.rst.inc b/book/map.rst.inc
deleted file mode 100644
index 16e7083b..00000000
--- a/book/map.rst.inc
+++ /dev/null
@@ -1,6 +0,0 @@
-* :doc:`installation`
-* :doc:`simplecms`
-* :doc:`routing`
-* :doc:`database_layer`
-* :doc:`static_content`
-* :doc:`structuring_content`
diff --git a/book/routing.rst b/book/routing.rst
deleted file mode 100644
index bdb2df39..00000000
--- a/book/routing.rst
+++ /dev/null
@@ -1,538 +0,0 @@
-.. index::
-    single: Routing; Getting Started
-    single: CmfRoutingBundle
-
-Routing
-=======
-
-This is an introduction to understand the concepts behind CMF routing. For the
-reference documentation please see the documentation for the
-:doc:`Routing component <../components/routing/introduction>` and the
-:doc:`RoutingBundle <../bundles/routing/introduction>`.
-
-Concept
--------
-
-Why a new Routing Mechanism?
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-CMS are highly dynamic sites, where most of the content is managed by the
-administrators rather than developers. The number of available pages can
-easily reach the thousands, which is usually multiplied by the number of
-available translations. Best accessibility and SEO practices, as well as user
-preferences dictate that the URLs should be definable by the content managers.
-
-The default Symfony2 routing mechanism, with its configuration file approach,
-is not the best solution for this problem. It does not provide a way of handling
-dynamic, user-defined routes, nor does it scale well to a large number of routes.
-
-The Solution
-~~~~~~~~~~~~
-
-In order to address these issues, a new routing system needed to be developed
-that takes into account the typical needs of CMS routing:
-
-* User-defined URLs;
-* Multi-site;
-* Multi-language;
-* Tree-like structure for easier management;
-* Content, Menu and Route separation for added flexibility.
-
-The Symfony CMF Routing component was created with these requirements in mind.
-
-The ``ChainRouter``
--------------------
-
-At the core of Symfony CMF's Routing component sits the ``ChainRouter``.
-It is used as a replacement for Symfony2's default routing system and,
-like the Symfony2 router, is responsible for determining which Controller
-will handle each request.
-
-The ``ChainRouter`` works by accepting a set of prioritized routing
-strategies, :class:`Symfony\\Component\\Routing\\RouterInterface`
-implementations, commonly referred to as "Routers". The routers are
-responsible for matching an incoming request to an actual Controller and, to
-do so, the ``ChainRouter`` iterates over the configured Routers according to
-their configured priority:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/config.yml
-        cmf_routing:
-            chain:
-                routers_by_id:
-                    # enable the DynamicRouter with a low priority
-                    # this way the non dynamic routes take precedence
-                    # to prevent needless database look ups
-                    cmf_routing.dynamic_router: 20
-
-                    # enable the symfony default router with a higher priority
-                    router.default: 100
-
-    .. code-block:: xml
-
-        <!-- app/config/config.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-
-        <container xmlns="http://cmf.symfony.com/schema/dic/services">
-
-            <config xmlns="http://cmf.symfony.com/schema/dic/routing">
-                <chain>
-                    <!-- enable the DynamicRouter with a low priority
-                         this way the non dynamic routes take precedence
-                         to prevent needless database look ups -->
-                    <routers-by-id
-                        id="cmf_routing.dynamic_router">
-                        20
-                    </routers-by-id>
-
-                    <!-- enable the symfony default router with a higher priority -->
-                    <routers-by-id
-                        id="router.default">
-                        100
-                    </routers-by-id>
-                </chain>
-            </config>
-
-    .. code-block:: php
-
-        // app/config/config.php
-        $container->loadFromExtension('cmf_routing', array(
-            'chain' => array(
-                'routers_by_id' => array(
-                    // enable the DynamicRouter with a low priority
-                    // this way the non dynamic routes take precedence
-                    // to prevent needless database look ups
-                    'cmf_routing.dynamic_router' => 20,
-
-                    // enable the symfony default router with a higher priority
-                    'router.default' => 100,
-                ),
-            ),
-        ));
-
-You can also load Routers using tagged services, by using the ``router`` tag
-and an optional ``priority``. The higher the priority, the earlier your router
-will be asked to match the route. If you do not specify the priority, your
-router will come last. If there are several routers with the same priority,
-the order between them is undetermined. The tagged service will look like
-this:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        services:
-            my_namespace.my_router:
-                class: "%my_namespace.my_router_class%"
-                tags:
-                    - { name: router, priority: 300 }
-
-    .. code-block:: xml
-
-        <service id="my_namespace.my_router" class="%my_namespace.my_router_class%">
-            <tag name="router" priority="300" />
-        </service>
-
-    .. code-block:: php
-
-        $container
-            ->register('my_namespace.my_router', '%my_namespace.my_router_class%')
-            ->addTag('router', array('priority' => 300))
-        ;
-
-The Symfony CMF Routing system adds a new ``DynamicRouter``, which complements
-the default ``Router`` found in Symfony2.
-
-The Default Symfony2 Router
----------------------------
-
-Although it replaces the default routing mechanism, Symfony CMF Routing allows
-you to keep using the existing system. In fact, the standard Symfony2 routing
-is enabled by default, so you can keep using the routes you declared in your
-configuration files, or as declared by other bundles.
-
-.. _start-routing-dynamic-router:
-
-The DynamicRouter
------------------
-
-This Router can dynamically load ``Route`` instances from a dynamic source via
-a so called *provider*. In fact it only loads candidate routes. The actual
-matching process is exactly the same as with the standard Symfony2 routing
-mechanism. However the ``DynamicRouter`` additionally is able to determine
-which Controller and Template to use based on the ``Route`` that is matched.
-
-By default the ``DynamicRouter`` is disabled. To activate it, just add the
-following to your configuration file:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/config.yml
-        cmf_routing:
-            dynamic:
-                enabled: true
-
-    .. code-block:: xml
-
-        <!-- app/config/config.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-
-        <container xmlns="http://cmf.symfony.com/schema/dic/services"
-            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-
-            <config xmlns="http://cmf.symfony.com/schema/dic/routing">
-                <dynamic enabled="true" />
-            </config>
-        </container>
-
-    .. code-block:: php
-
-        // app/config/config.php
-        $container->loadFromExtension('cmf_routing', array(
-            'dynamic' => array(
-                'enabled' => true,
-            ),
-        ));
-
-This is the minimum configuration required to load the ``DynamicRouter`` as a
-service, thus making it capable of performing routing. Actually, when you
-browse the default pages that come with the Symfony CMF SE, it is the
-``DynamicRouter`` that matches your requests with the Controllers and
-Templates.
-
-.. _start-routing-getting-route-object:
-
-Getting the Route Object
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-The provider to use can be configured to best suit each implementation's
-needs. As part of this bundle, an implementation for `Doctrine ORM`_ and
-`PHPCR-ODM`_ is provided. Also, you can easily create your own by simply
-implementing the ``RouteProviderInterface``. Providers are responsible
-for fetching an ordered subset of candidate routes that could match the
-request. For example the default `PHPCR-ODM`_ provider loads the ``Route``
-at the path in the request and all parent paths to allow for some of the
-path segments being parameters.
-
-For more detailed information on this implementation and how you can customize
-or extend it, refer to :doc:`../bundles/routing/introduction`.
-
-The ``DynamicRouter`` is able to match the incoming request to a Route object
-from the underlying provider. The details on how this matching process is
-carried out can be found in the
-:doc:`component documentation <../components/routing/dynamic>`.
-
-.. note::
-
-    To have the route provider find routes, you also need to provide the data
-    in your storage. With PHPCR-ODM, this is either done through the admin
-    interface (see at the bottom) or with fixtures.
-
-    However, before we can explain how to do that, you need to understand how
-    the ``DynamicRouter`` works. An example will come
-    :ref:`later in this document <start-routing-document>`.
-
-.. _start-routing-getting-controller-template:
-
-Getting the Controller and Template
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-A Route needs to specify which Controller should handle a specific Request.
-The ``DynamicRouter`` uses one of several possible methods to determine it (in
-order of precedence):
-
-* Explicit: The ``Route`` document itself can explicitly declare the target
-  Controller if one is returned from ``getDefault('_controller')``.
-* By type: The ``Route`` document returns a value from ``getDefault('type')``,
-  which is then matched against the provided configuration from config.yml
-* By class: Requires the ``Route`` document to implement ``RouteObjectInterface``
-  and return an object for ``getContent()``. The returned class type is
-  then matched against the provided configuration from config.yml.
-* Default: If configured, a default Controller will be used.
-
-Apart from this, the ``DynamicRouter`` is also capable of dynamically
-specifying which Template will be used, in a similar way to the one used to
-determine the Controller (in order of precedence):
-
-* Explicit: The stored Route document itself can explicitly declare the target
-  Template by returning the name of the template via ``getDefault('_template')``.
-* By class: Requires the Route instance to implement ``RouteObjectInterface``
-  and return an object for ``getContent()``. The returned class type is
-  then matched against the provided configuration from config.yml.
-
-Here's an example of how to configure the above mentioned options:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/config.yml
-        cmf_routing:
-            dynamic:
-                generic_controller: cmf_content.controller:indexAction
-                controllers_by_type:
-                    editable_static: sandbox_main.controller:indexAction
-                controllers_by_class:
-                    Symfony\Cmf\Bundle\ContentBundle\Document\StaticContent: cmf_content.controller::indexAction
-                templates_by_class:
-                    Symfony\Cmf\Bundle\ContentBundle\Document\StaticContent: CmfContentBundle:StaticContent:index.html.twig
-
-    .. code-block:: xml
-
-        <!-- app/config/config.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-
-        <container xmlns="http://cmf.symfony.com/schema/dic/services"
-            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-
-            <config xmlns="http://cmf.symfony.com/schema/dic/routing">
-                <dynamic generic-controller="cmf_content.controller:indexAction">
-                    <controllers-by-type type="editable_static">
-                        sandbox_main.controller:indexAction
-                    </controllers-by-type>
-
-                    <controllers-by-class
-                        class="Symfony\Cmf\Bundle\ContentBundle\Document\StaticContent"
-                    >
-                        cmf_content.controller::indexAction
-                    </controllers-by-class>
-
-                    <templates-by-class class="Symfony\Cmf\Bundle\ContentBundle\Document\StaticContent"
-                    >
-                        CmfContentBundle:StaticContent:index.html.twig
-                    </templates-by-class>
-                </dynamic>
-            </config>
-        </container>
-
-    .. code-block:: php
-
-        // app/config/config.php
-        $container->loadFromExtension('cmf_routing', array(
-            'dynamic' => array(
-                'generic_controller' => 'cmf_content.controller:indexAction',
-                'controllers_by_type' => array(
-                    'editable_static' => 'sandbox_main.controller:indexAction',
-                ),
-                'controllers_by_class' => array(
-                    'Symfony\Cmf\Bundle\ContentBundle\Document\StaticContent' => 'cmf_content.controller::indexAction',
-                ),
-                'templates_by_class' => array(
-                    'Symfony\Cmf\Bundle\ContentBundle\Document\StaticContent' => 'CmfContentBundle:StaticContent:index.html.twig',
-                ),
-            ),
-        ));
-
-Notice that ``enabled: true`` is no longer present. It's only required if no
-other configuration parameter is provided. The router is automatically enabled
-as soon as you add any other configuration to the ``dynamic`` entry.
-
-.. note::
-
-    This example uses a controller which is defined as a service. You can also
-    configure a controller by using a fully qualified class name:
-    ``CmfContentBundle:Content:index``.
-
-    For more information on using controllers as a service read cook book
-    section `How to Define Controllers as Services`_
-
-.. note::
-
-    Internally, the routing component maps these configuration options to
-    several ``RouteEnhancerInterface`` instances. The actual scope of these
-    enhancers is much wider, and you can find more information about them in
-    the :ref:`routing enhancers <component-routing-enhancers>` documentation
-    section.
-
-.. _start-routing-linking-a-route-with-a-model-instance:
-
-Linking a Route with a Model Instance
--------------------------------------
-
-Depending on your application's logic, a requested URL may have an associated
-model instance from the database. Those Routes can implement the
-``RouteObjectInterface``, and optionally return a model instance, that will be
-automatically passed to the Controller as the ``contentDocument`` method parameter.
-
-Note that a Route can implement the above mentioned interface but still not
-return any model instance, in which case no associated object will be provided.
-
-Furthermore, Routes that implement this interface can also provide their own
-name with the ``getRouteKey`` method. For normal Symfony routes, the name is
-only known from their key in the ``RouteCollection`` collection hashmap. In the
-CMF, it is possible to use route documents outside of collections, and thus
-useful to have routes provide their name. The PHPCR routes for example return
-the repository path when this method is called.
-
-Redirects
----------
-
-You can build redirects by implementing the ``RedirectRouteInterface``. If
-you are using the default ``PHPCR-ODM`` route provider, a ready to use
-implementation is provided in the ``RedirectRoute`` Document. It can redirect
-either to an absolute URI, to a named Route that can be generated by any
-Router in the chain or to another Route object known to the route provider.
-The actual redirection is handled by a specific Controller that can be
-configured as follows:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/config.yml
-        cmf_routing:
-            dynamic:
-                controllers_by_class:
-                    Symfony\Cmf\Component\Routing\RedirectRouteInterface: cmf_routing.redirect_controller:redirectAction
-
-    .. code-block:: xml
-
-        <!-- app/config/config.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-
-        <container xmlns="http://cmf.symfony.com/schema/dic/services"
-            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
-
-            <config xmlns="http://cmf.symfony.com/schema/dic/routing">
-                <dynamic>
-                    <controllers-by-class
-                        class="Symfony\Cmf\Component\Routing\RedirectRouteInterface">
-                        cmf_routing.redirect_controller:redirectAction
-                    </controllers-by-class>
-                </dynamic>
-            </config>
-        </container>
-
-    .. code-block:: php
-
-        // app/config/config.php
-        $container->loadFromExtension('cmf_routing', array(
-            'dynamic' => array(
-                'controllers_by_class' => array(
-                    'Symfony\Cmf\Component\Routing\RedirectRouteInterface' => 'cmf_routing.redirect_controller:redirectAction',
-                ),
-            ),
-        ));
-
-.. note::
-
-    The actual configuration for this association exists as a service, not as
-    part of a ``config.yml`` file. As discussed before, any of the
-    approaches can be used.
-
-URL Generation
---------------
-
-Symfony CMF's Routing component uses the default Symfony2 components to handle
-route generation, so you can use the default methods for generating your URLs
-with a few added possibilities:
-
-* Pass an implementation of either ``RouteObjectInterface`` or
-  ``RouteReferrersInterface`` as the ``name`` parameter
-* Alternatively, supply an implementation of ``ContentRepositoryInterface`` and
-  the id of the model instance as parameter ``content_id``
-
-See :ref:`bundles-routing-dynamic-generator` for code examples of all above
-cases.
-
-The route generation handles locales as well, see
-":ref:`ContentAwareGenerator and Locales <component-route-generator-and-locales>`".
-
-.. _start-routing-document:
-
-The PHPCR-ODM Route Document
-----------------------------
-
-As mentioned above, you can use any route provider. The example in this
-section applies if you use the default PHPCR-ODM route provider
-(``Symfony\Cmf\Bundle\RoutingBundle\Doctrine\Phpcr\RouteProvider``).
-
-PHPCR-ODM documents are stored in a tree, and their ID is the path in that
-tree. To match routes, a part of the repository path is used as URL. To avoid
-mixing routes and other documents, routes are placed under a common root path
-and that path is removed from the ID to build the URL. The common root path is
-called "route basepath". The default base path is ``/cms/routes``. A new route
-can be created in PHP code as follows::
-
-    // src/Acme/MainBundle/DataFixtures/PHPCR/LoadRoutingData.php
-    namespace Acme\DemoBundle\DataFixtures\PHPCR;
-
-    use Doctrine\ODM\PHPCR\DocumentManager;
-    use Doctrine\Common\DataFixtures\FixtureInterface;
-    use Doctrine\Common\Persistence\ObjectManager;
-    use Symfony\Cmf\Bundle\RoutingBundle\Doctrine\Phpcr\Route;
-    use Symfony\Cmf\Bundle\ContentBundle\Doctrine\Phpcr\StaticContent;
-    use PHPCR\Util\NodeHelper;
-
-    class LoadRoutingData implements FixtureInterface
-    {
-        /**
-         * @param DocumentManager $dm
-         */
-        public function load(ObjectManager $dm)
-        {
-            if (!$dm instanceof DocumentManager) {
-                $class = get_class($dm);
-                throw new \RuntimeException("Fixture requires a PHPCR ODM DocumentManager instance, instance of '$class' given.");
-            }
-
-            $session = $dm->getPhpcrSession();
-            NodeHelper::createPath($session, '/cms/routes');
-
-            $route = new Route();
-            $route->setParentDocument($dm->find(null, '/cms/routes'));
-            $route->setName('my-page');
-
-            // link a content to the route
-            $content = new StaticContent();
-            $content->setParentDocument($dm->find(null, '/cms/content'));
-            $content->setName('my-content');
-            $content->setTitle('My Content');
-            $content->setBody('Some Content');
-            $dm->persist($content);
-            $route->setContent($content);
-
-            $dm->persist($route);
-            $dm->flush();
-        }
-    }
-
-Now the CMF will be able to handle requests for the URL ``/my-content``.
-
-.. caution::
-
-    As you can see, the code explicitly creates the ``/cms/routes`` path.
-    The RoutingBundle only creates this path automatically if the Sonata Admin
-    was enabled in the routing configuration using an :ref:`initializer
-    <phpcr-odm-repository-initializers>`. Otherwise, it'll assume you do
-    something yourself to create the path (by configuring an initializer or
-    doing it in a fixture like this).
-
-Because you called ``setContent`` on the route, the controller can expect the
-``$contentDocument`` parameter. You can now configure which controller should
-handle ``StaticContent`` as :ref:`explained above <start-routing-getting-controller-template>`.
-
-The PHPCR-ODM routes support more things, for example route parameters,
-requirements and defaults. This is explained in the
-:ref:`route document section in the RoutingBundle documentation <bundles-routing-document>`.
-You can also find :ref:`route entity documentation and Doctrine ORM integration <bundles-routing-entity>`.
-
-Further Notes
--------------
-
-For more information on the Routing component of Symfony CMF, please refer to:
-
-* :doc:`../components/routing/introduction` for most of the actual functionality implementation
-* :doc:`../bundles/routing/introduction` for Symfony2 integration bundle for Routing Bundle
-* Symfony2's `Routing`_ component page
-* :doc:`../book/handling_multilang` for some notes on multilingual routing
-
-.. _`Doctrine ORM`: http://www.doctrine-project.org/projects/orm.html
-.. _`PHPCR-ODM`: http://www.doctrine-project.org/projects/phpcr-odm.html
-.. _`Routing`: https://symfony.com/doc/current/components/routing/introduction.html
-.. _`How to Define Controllers as Services`: https://symfony.com/doc/current/cookbook/controller/service.html
diff --git a/book/simplecms.rst b/book/simplecms.rst
deleted file mode 100644
index 64579dbf..00000000
--- a/book/simplecms.rst
+++ /dev/null
@@ -1,164 +0,0 @@
-.. index::
-    single: SimpleCms
-
-First look at the internals
-===========================
-
-In most CMS use cases the most basic need is to associate content with a URL.
-In the Symfony CMF, this is done by using a powerful routing system, provided
-by the RoutingBundle, and the ContentBundle. The RoutingBundle provides a
-``Route`` object which can be associated with the ``Content`` object of the
-ContentBundle.
-
-Having two objects is the most flexible solution. You can have different
-routes (e.g. per language) for the same content. Or you can organize your
-content differently than your URL tree. But in many situations,
-having the route and the content be one and the same simplifies things. That
-is exactly what the SimpleCmsBundle is doing, which is used by the Symfony
-CMF Standard Edition by default for routing, content and menus.
-
-.. note::
-
-    It's important to know that the SimpleCmsBundle is just a simple example
-    how you can combine the CMF bundles into a complete CMS. Feel free to
-    extend the SimpleCmsBundle or create your own bundle to do this task.
-
-.. tip::
-
-    To learn more about the routing, see ":doc:`routing`". To learn more about
-    content storage, see ":doc:`static_content`". Finally, to learn more about
-    menus, see ":doc:`structuring_content`".
-
-Page Document
-~~~~~~~~~~~~~
-
-The SimpleCmsBundle provides a class called ``Page`` which extends from the core
-``Route`` class and provides properties to store content and also implements the
-``NodeInterface``, so you can use inside the menu. This three-in-one approach is
-the key concept behind the bundle.
-
-The mapping of the ``Page`` to a template and controller works as explained in
-the :doc:`next chapter <routing>`.
-
-Creating a new Page
-~~~~~~~~~~~~~~~~~~~
-
-To create a page, use the
-``Symfony\Cmf\Bundle\SimpleCmsBundle\Doctrine\Phpcr\Page`` object::
-
-    // // src/Acme/MainBundle/DataFixtures/PHPCR/LoadSimpleCms.php
-    namespace Acme\DemoBundle\DataFixtures\PHPCR;
-
-    use Doctrine\Common\DataFixtures\FixtureInterface;
-    use Doctrine\Common\Persistence\ObjectManager;
-    use Doctrine\ODM\PHPCR\DocumentManager;
-    use Symfony\Cmf\Bundle\SimpleCmsBundle\Doctrine\Phpcr\Page;
-
-    class LoadSimpleCms implements FixtureInterface
-    {
-        /**
-         * @param DocumentManager $dm
-         */
-        public function load(ObjectManager $dm)
-        {
-            if (!$dm instanceof DocumentManager) {
-                $class = get_class($dm);
-                throw new \RuntimeException("Fixture requires a PHPCR ODM DocumentManager instance, instance of '$class' given.");
-            }
-
-            $parent = $dm->find(null, '/cms/simple');
-            $page = new Page();
-            $page->setTitle('About Symfony CMF');
-            $page->setLabel('About');
-            $page->setBody(...);
-
-            // the tree position defines the URL
-            $page->setPosition($parent, 'about');
-
-            $dm->persist($page);
-            $dm->flush();
-        }
-    }
-
-You can also set other options on the Page (e.g. tags).
-
-All pages are stored in a simple tree structure. To set the position, use
-``setPosition``. The first argument is the parent document, the second the
-name for this page. The names are used for the URL. For instance, you may
-have the following tree structure:
-
-.. code-block:: text
-
-    /cms/simple/
-        about/
-        blog/
-            symfony-cmf-is-great/
-
-In this case, you have 4 pages: the page at ``/cms/simple``, ``about``,
-``blog`` and ``symfony-cmf-is-great``. The page at the home has the path
-``/``. The page ``symfony-cmf-is-great`` is a child of ``blog`` and thus
-has the path ``/blog/symfony-cmf-is-great``. To create such a
-structure, you would do::
-
-
-    // // src/Acme/MainBundle/DataFixtures/PHPCR/LoadSimpleCms.php
-    namespace Acme\DemoBundle\DataFixtures\PHPCR;
-
-    use Doctrine\Common\DataFixtures\FixtureInterface;
-    use Doctrine\Common\Persistence\ObjectManager;
-    use Doctrine\ODM\PHPCR\DocumentManager;
-    use Symfony\Cmf\Bundle\SimpleCmsBundle\Doctrine\Phpcr\Page;
-
-    class LoadSimpleCms implements FixtureInterface
-    {
-        /**
-         * @param DocumentManager $dm
-         */
-        public function load(ObjectManager $dm)
-        {
-            if (!$dm instanceof DocumentManager) {
-                $class = get_class($dm);
-                throw new \RuntimeException("Fixture requires a PHPCR ODM DocumentManager instance, instance of '$class' given.");
-            }
-
-            $root = $dm->find(null, '/cms/simple');
-
-            $about = new Page();
-            // ... set up about
-            $about->setPosition($root, 'about');
-
-            $dm->persist($about);
-
-            $blog = new Page();
-            // ... set up blog
-            $blog->setPosition($root, 'blog');
-
-            $dm->persist($blog);
-
-            $blogPost = new Page();
-            // ... set up blog post
-            $blogPost->setPosition($blog, 'symfony-cmf-is-great');
-
-            $dm->persist($blogPost);
-
-            $dm->flush();
-        }
-    }
-
-Every PHPCR-ODM document must have a parent document. Parents are never
-created automatically, so we use the PHPCR NodeHelper to ensure we have
-the root element (``/cms/simple`` in this case).
-
-.. note::
-
-    The Page at ``/cms/simple`` is created by an
-    :ref:`initializer <phpcr-odm-repository-initializers>` of the
-    SimpleCmsBundle.
-
-Summary
--------
-
-Congratulations! You are now able to create a simple web site using the
-Symfony CMF. From here, each chapter will tell you a bit more about the CMF
-and more about the things behind the SimpleCMSBundle. In the end, you'll be
-able to create more advanced blog systems and other CMS websites.
diff --git a/book/static_content.rst b/book/static_content.rst
deleted file mode 100644
index e0a5dd5f..00000000
--- a/book/static_content.rst
+++ /dev/null
@@ -1,81 +0,0 @@
-.. index::
-    single: Static Content; Book
-    single: CmfContentBundle
-
-Static Content
-==============
-
-Concept
--------
-
-At the heart of every CMS stands the content, an abstraction that the
-publishers can manipulate and that will later be presented to the page's
-users. The content's structure greatly depends on the project's needs, and it
-will have a significant impact on future development and use of the platform.
-
-The ContentBundle provides a basic implementation of a content document classes,
-including support for multiple languages and association to Routes.
-
-Static Content
---------------
-
-The ``StaticContent`` class declares the basic content's structure. Its structure
-is very similar to the ones used on Symfony2's ORM systems. Most of its
-fields are self explanatory and are what you would expect from a basic CMS:
-title, body, publishing information and a parent reference, to accommodate a
-tree-like hierarchy. It also includes a Block reference (more on that later).
-
-This document class implements three interfaces that enable additional functionality:
-
-* ``RouteReferrersInterface`` means that the content has associated Routes.
-* ``PublishTimePeriodInterface`` means that the content has publishing and
-   unpublishing dates, which will be handled by Symfony CMF's core to
-   determine whether or not to display the content from ``StaticContent``
-* ``PublishableInterface`` means that the content has a boolean flag,
-   which will be handled by Symfony CMF's core to
-   determine whether or not to display the content from ``StaticContent``.
-
-Content Controller
-------------------
-
-A controller is also included that can render either of the above content
-document types. Its single action, ``indexAction``, accepts a content
-instance and optionally the path of the template to be used for rendering.
-If no template path is provided, it uses a pre-configured default.
-
-The controller action also takes into account the document's publishing status
-and language (for ``MultilangStaticContent``). Both the content instance and the
-optional template are provided to the controller by the ``DynamicRouter`` of
-the RoutingBundle. More information on this is available on the
-:ref:`Routing system getting started page <start-routing-linking-a-route-with-a-model-instance>`
-page.
-
-Admin Support
--------------
-
-The last component needed to handle the included content types is an
-administration panel. Symfony CMF can optionally support
-SonataDoctrinePHPCRAdminBundle_, a back office generation tool.
-
-In ContentBundle, the required administration panels are already declared in
-the ``Admin`` folder and configured in ``Resources/config/admin.xml``, and
-will automatically be loaded if you install the SonataDoctrinePHPCRAdminBundle
-(refer to :doc:`../tutorial/sonata-admin` for
-instructions on that).
-
-Configuration
--------------
-
-The ContentBundle also supports a set of optional configuration parameters. Refer to
-:doc:`../bundles/content/index` for the full configuration reference.
-
-Final Thoughts
---------------
-
-While this small bundle includes some vital components to a fully working CMS,
-it often will not provide all you need. The main idea behind it is to provide
-developers with a small and easy to understand starting point you can extend
-or use as inspiration to develop your own content types, Controllers and Admin
-panels.
-
-.. _SonataDoctrinePHPCRAdminBundle: https://github.com/sonata-project/SonataDoctrinePhpcrAdminBundle
diff --git a/book/structuring_content.rst b/book/structuring_content.rst
deleted file mode 100644
index 62a6731d..00000000
--- a/book/structuring_content.rst
+++ /dev/null
@@ -1,175 +0,0 @@
-.. index::
-    single: Menu; Getting Started
-    single: CmfMenuBundle
-
-Structuring Content
-===================
-
-Menu Bundle
------------
-
-Concept
-~~~~~~~
-
-No CMS system is complete without a menu system that allows users to navigate
-between content pages and perform certain actions. While it usually maps
-the actual content tree structure, menus often have a logic of their own,
-include options not mapped by content or exist in multiple contexts with
-multiple options, thus making them a complex problem themselves.
-
-Symfony CMF Menu System
-~~~~~~~~~~~~~~~~~~~~~~~
-
-Symfony CMF SE includes the MenuBundle, a tool that allow you to dynamically
-define your menus. It extends the KnpMenuBundle_, with a set of
-hierarchical, multi language menu elements, along with the tools to persist
-them in the chosen content store. It also includes the administration panel
-definitions and related services needed for integration with the
-SonataDoctrinePHPCRAdminBundle_.
-
-.. note::
-
-    The MenuBundle extends and greatly relies on the KnpMenuBundle_, so you
-    should carefully read `KnpMenuBundle's documentation`_. For the rest of
-    this page we assume you have done so and are familiar with concepts like
-    Menu Providers and Menu Factories.
-
-Usage
-.....
-
-The MenuBundle uses KnpMenuBundle's default renderers and helpers to print out
-menus. You can refer to the `respective documentation page`_ for more
-information on the subject, but a basic call would be:
-
-.. configuration-block::
-
-    .. code-block:: jinja
-
-        {{ knp_menu_render('simple') }}
-
-    .. code-block:: php
-
-        <?php echo $view['knp_menu']->render('simple') ?>
-
-The provided menu name will be passed on to ``MenuProviderInterface``
-implementation, which will use it to identify which menu you want rendered in
-this specific section.
-
-The Provider
-............
-
-The core of the MenuBundle is ``PhpcrMenuProvider``, a
-``MenuProviderInterface`` implementation that's responsible for dynamically
-loading menus from a PHPCR database. The default provider service is
-configured with a ``menu_basepath`` to know where in the PHPCR tree it will
-find menus. The menu ``name`` is given when rendering the menu and must be a
-direct child of the menu base path. This allows the ``PhpcrMenuProvider`` to
-handle several menu hierarchies using a single storage mechanism.
-
-To give a concrete example, if we have the configuration as given below and
-render the menu ``simple``, the menu root node must be stored at
-``/cms/menu/simple``.
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        cmf_menu:
-            menu_basepath: /cms/menu
-
-    .. code-block:: xml
-
-        <?xml version="1.0" encoding="UTF-8" ?>
-
-        <container
-            xmlns="http://symfony.com/schema/dic/services"
-            xmlns:cmf-menu="http://cmf.symfony.com/schema/dic/menu">
-
-            <cmf-menu:config menu-basepath="/cms/menu"/>
-        </container>
-
-    .. code-block:: php
-
-        $container->loadFromExtension('cmf_menu', array(
-            'menu_basepath' => '/cms/menu',
-        ));
-
-If you need multiple menu roots, you can create further ``PhpcrMenuProvider``
-instances and register them with KnpMenu - see the CMF MenuBundle
-``DependencyInjection`` code for the details.
-
-The menu element fetched using this process is used as the menu root node, and
-its children will be loaded progressively as the full menu structure is
-rendered by the ``MenuFactory``.
-
-The Factory
-...........
-
-Menu factories generate the full ``MenuItem`` hierarchy from the provided
-menu node. The data generated this way is later used to generate the actual
-HTML representation of the menu.
-
-The included implementation focuses on generating ``MenuItem`` instances from
-``NodeInterface`` instances, as this is usually the best approach to handle
-tree-like structures typically used by a CMS. Other approaches are implemented in
-the base classes and their respective documentation pages can be found in
-KnpMenuBundle_'s page.
-
-``KnpMenu`` already includes a specific factory targeted at the Symfony Routing
-component to add support for:
-
-* ``Route`` instances stored in a database (refer to
-  :ref:`RoutingBundle's RouteProvider <start-routing-getting-route-object>` for
-  more details on this)
-* ``Route`` instances with associated content (more on this on respective
-  :ref:`RoutingBundle's section <start-routing-linking-a-route-with-a-model-instance>`)
-
-As mentioned before, the factory is responsible for loading all the menu nodes
-from the provided root element. The actual loaded nodes can be of any class,
-even if it's different from the root's, but all must implement
-``NodeInterface`` in order to be included in the generated menu.
-
-The Menu Nodes
-..............
-
-Also included in the MenuBundle is the ``MenuNode`` document. If you have
-read the documentation page regarding :doc:`static_content`, you'll find
-this implementation somewhat familiar.
-
-``MenuNode`` implements the above mentioned ``NodeInterface``, and holds the
-information regarding a single menu entry: a ``label`` and a ``uri``, a
-``children`` list, plus some ``attributes`` for the node
-and its children that will allow the rendering process to be
-customized. It also includes a ``Route`` field and two references to
-Contents. These are used to store an associated ``Route`` object, plus one
-(not two, despite the fact that two fields exist) Content element. The
-``MenuNode`` can have a strong (integrity ensured) or weak (integrity not
-ensured) reference to the actual Content element it points to; it's up to you
-to choose which best fits your scenario. You can find more information on
-references on the `Doctrine PHPCR documentation page`_.
-
-Admin Support
-~~~~~~~~~~~~~
-
-The MenuBundle also includes the administration panels and respective services
-needed for integration with the backend admin tool
-SonataDoctrinePHPCRAdminBundle_.
-
-The included administration panels are automatically available but need to
-be explicitly put on the dashboard if you want to use them. See
-:doc:`../tutorial/sonata-admin` for instructions on how to install
-SonataDoctrinePHPCRAdminBundle.
-
-Configuration
-~~~~~~~~~~~~~
-
-This bundle is configurable using a set of parameters, but all of them are
-optional. You can go to the :doc:`../bundles/menu/index` reference page for the full
-configuration options list and additional information.
-
-.. _KnpMenuBundle: https://github.com/knplabs/KnpMenuBundle
-.. _`KnpMenuBundle's documentation`: https://symfony.com/doc/master/bundles/KnpMenuBundle/index.html
-.. _`respective documentation page`: https://symfony.com/doc/master/bundles/KnpMenuBundle/index.html#rendering-menus
-.. _`Doctrine PHPCR documentation page`: http://docs.doctrine-project.org/projects/doctrine-phpcr-odm/en/latest/reference/association-mapping.html#references
-.. _`KnpMenu`: https://github.com/knplabs/KnpMenu
-.. _SonataDoctrinePHPCRAdminBundle: https://sonata-project.org/bundles/doctrine-phpcr-admin/master/doc/index.html
diff --git a/bundles/content/introduction.rst b/bundles/content/introduction.rst
index 1a12142c..6d09454f 100644
--- a/bundles/content/introduction.rst
+++ b/bundles/content/introduction.rst
@@ -8,9 +8,6 @@ ContentBundle
     The ContentBundle provides a document for static content and the controller
     to render any content that needs no special handling in the controller.
 
-For an introduction see the ":doc:`../../book/static_content`" article of the
-"Book" section.
-
 Installation
 ------------
 
diff --git a/bundles/core/publish_workflow.rst b/bundles/core/publish_workflow.rst
index c160f0a6..d678212a 100644
--- a/bundles/core/publish_workflow.rst
+++ b/bundles/core/publish_workflow.rst
@@ -15,11 +15,6 @@ workflow. This means that if you always have a firewall, you can just use
 the normal security context and the Twig function ``is_granted`` to check for
 publication.
 
-.. tip::
-
-    A good introduction to the Symfony core security can be found in the
-    `Security Chapter`_ of the Symfony2 book.
-
 The default publish workflow corresponds to the following diagram:
 
 .. image:: ../../_images/bundles/core_pwf_workflow.png
@@ -376,7 +371,6 @@ There is a :doc:`Sonata admin extension <../sonata_phpcr_admin_integration/core>
 available to edit workflow information on any document implementing the
 interface.
 
-.. _`Symfony2 security component`: https://symfony.com/doc/current/components/security/index.html
-.. _`Symfony2 Authorization`: https://symfony.com/doc/current/components/security/authorization.html
-.. _`Security Chapter`: https://symfony.com/doc/current/book/security.html
-.. _`ACL checks`: https://symfony.com/doc/current/cookbook/security/acl.html
+.. _`Symfony2 security component`: http://symfony.com/doc/current/components/security.html
+.. _`Symfony2 Authorization`: http://symfony.com/doc/current/components/security/authorization.html
+.. _`ACL checks`: http://symfony.com/doc/current/security/acl.html
diff --git a/bundles/phpcr_odm/configuration.rst b/bundles/phpcr_odm/configuration.rst
index ac958679..39bf7114 100644
--- a/bundles/phpcr_odm/configuration.rst
+++ b/bundles/phpcr_odm/configuration.rst
@@ -15,7 +15,7 @@ Configuration
 .. tip::
 
     You can also configure multiple session. See
-    :doc:`../phpcr_odm/multiple_sessions` for details.
+    :doc:`multiple_sessions` for details.
 
 .. configuration-block::
 
@@ -434,7 +434,7 @@ not configure anything here, the ODM services will not be loaded.
 .. tip::
 
     You can also configure multiple document managers. See
-    :doc:`../phpcr_odm/multiple_sessions` for details.
+    :doc:`multiple_sessions` for details.
 
 .. configuration-block::
 
diff --git a/bundles/phpcr_odm/index.rst b/bundles/phpcr_odm/index.rst
index eb01e881..bd00e807 100644
--- a/bundles/phpcr_odm/index.rst
+++ b/bundles/phpcr_odm/index.rst
@@ -5,6 +5,7 @@ DoctrinePHPCRBundle
     :maxdepth: 2
 
     introduction
+    models
     events
     forms
     fixtures_initializers
diff --git a/bundles/phpcr_odm/introduction.rst b/bundles/phpcr_odm/introduction.rst
index d652be95..a8e876bb 100644
--- a/bundles/phpcr_odm/introduction.rst
+++ b/bundles/phpcr_odm/introduction.rst
@@ -5,6 +5,15 @@
 DoctrinePHPCRBundle
 ===================
 
+The Symfony CMF is storage layer agnostic, meaning that it can work with many
+storage layers. But by default, the Symfony CMF works with the
+`Doctrine PHPCR-ODM`_.
+
+.. tip::
+
+    Read more about choosing the correct storage layer in
+    :doc:`../../cookbook/database/choosing_storage_layer`
+
 The `DoctrinePHPCRBundle`_ provides integration with the PHP content
 repository and optionally with Doctrine PHPCR-ODM to provide the ODM document
 manager in symfony.
@@ -507,6 +516,7 @@ remove the target node first:
 Read On
 -------
 
+* :doc:`models`
 * :doc:`events`
 * :doc:`forms`
 * :doc:`fixtures_initializers`
@@ -514,6 +524,7 @@ Read On
 * :doc:`multiple_sessions`
 * :doc:`configuration`
 
+.. _`Doctrine PHPCR-ODM`: http://docs.doctrine-project.org/projects/doctrine-phpcr-odm/en/latest/index.html
 .. _`DoctrinePHPCRBundle`: https://github.com/doctrine/DoctrinePHPCRBundle
 .. _`Symfony2 Doctrine documentation`: https://symfony.com/doc/current/book/doctrine.html
 .. _`Jackalope`: http://jackalope.github.io/
diff --git a/book/database_layer.rst b/bundles/phpcr_odm/models.rst
similarity index 91%
rename from book/database_layer.rst
rename to bundles/phpcr_odm/models.rst
index 8469f30f..a197f4d0 100644
--- a/book/database_layer.rst
+++ b/bundles/phpcr_odm/models.rst
@@ -1,29 +1,9 @@
 .. index::
-    single: Database Layer
-    single: PHPCR-ODM
+    single: PHPCR; Bundles
+    single: DoctrinePHPCRBundle
 
-The Database Layer: PHPCR-ODM
-=============================
-
-The Symfony CMF is storage layer agnostic, meaning that it can work with many
-storage layers. By default, the Symfony CMF works with the `Doctrine PHPCR-ODM`_.
-In this chapter, you will learn how to work with the Doctrine PHPCR-ODM.
-
-.. tip::
-
-    Read more about choosing the correct storage layer in
-    :doc:`../cookbook/database/choosing_storage_layer`
-
-.. note::
-
-    This chapter assumes you are using a Symfony setup with PHPCR-ODM already
-    set up, like the :doc:`CMF Standard Edition <installation>`  or the
-    :doc:`CMF sandbox <../cookbook/editions/cmf_sandbox>`. See
-    :doc:`../bundles/phpcr_odm/introduction` for how to set up PHPCR-ODM in
-    your applications.
-
-PHPCR: A Tree Structure
------------------------
+Modeling Data with PHPCR-ODM
+============================
 
 The Doctrine PHPCR-ODM is a doctrine object-mapper on top of the
 `PHP Content Repository`_ (PHPCR), which is a PHP adaption of the
@@ -43,7 +23,7 @@ multi-language support.
 
     In order to let the Doctrine PHPCR-ODM communicate with the PHPCR, a PHPCR
     implementation is needed. See
-    ":doc:`../cookbook/database/choosing_phpcr_implementation`" for an overview
+    ":doc:`../../cookbook/database/choosing_phpcr_implementation`" for an overview
     of the available implementations.
 
 A Simple Example: A Task
@@ -185,7 +165,7 @@ After this, you have to create getters and setters for the properties.
 
     You may want to implement ``Doctrine\ODM\PHPCR\HierarchyInterface``
     which makes it for example possible to leverage the
-    :doc:`Sonata Admin Child Extension <../bundles/sonata_phpcr_admin_integration/core>`.
+    :doc:`Sonata Admin Child Extension <../sonata_phpcr_admin_integration/core>`.
 
 .. seealso::
 
@@ -365,10 +345,9 @@ table.
 
 And even though Doctrine revolves around a simple concept, it's incredibly
 powerful, allowing you to `create complex queries`_ and
-:doc:`subscribe to events <../bundles/phpcr_odm/events>` that allow you to
-take different actions as objects go through their persistence lifecycle.
+:doc:`subscribe to events <events>` that allow you to take different actions as
+objects go through their persistence lifecycle.
 
-.. _`Doctrine PHPCR-ODM`: http://docs.doctrine-project.org/projects/doctrine-phpcr-odm/en/latest/index.html
 .. _`PHP Content Repository`: http://phpcr.github.io/
 .. _`JSR-283 specification`: https://jcp.org/en/jsr/detail?id=283
 .. _`Doctrine ORM`: https://symfony.com/doc/current/book/doctrine.html
diff --git a/bundles/phpcr_odm/multilang.rst b/bundles/phpcr_odm/multilang.rst
index 2333ae15..b016484c 100644
--- a/bundles/phpcr_odm/multilang.rst
+++ b/bundles/phpcr_odm/multilang.rst
@@ -4,6 +4,13 @@
 Doctrine PHPCR-ODM Multi-Language Support
 =========================================
 
+PHPCR-ODM can handle translated documents. All translations of the same
+document are considered the same document. Only one language version can be
+loaded at the same time.
+
+Node that the CMF routing component does not use translated routes but has a
+:doc:`separate route per language <../routing/dynamic>`.
+
 To use the multi-language features of PHPCR-ODM you need to enable locales in
 the configuration.
 
diff --git a/bundles/routing/dynamic.rst b/bundles/routing/dynamic.rst
index 1695a8e8..b34bc900 100644
--- a/bundles/routing/dynamic.rst
+++ b/bundles/routing/dynamic.rst
@@ -474,8 +474,9 @@ The ``Post`` entity content in this example could be like this::
 
 Because you set the ``content_id`` default value on the route, the controller
 can expect the ``$contentDocument`` parameter. You can now configure which
-controller should handle ``Post`` entities as explained in the
-:ref:`Routing documentation <start-routing-getting-controller-template>`.
+template or which special controller should handle ``Post`` entities with the
+``templates_by_type`` resp. ``controllers_by_type`` configuration as explained
+in :doc:`configuration`.
 
 The ORM routes support more things, for example route parameters, requirements
 and defaults. This is explained in the
diff --git a/bundles/routing/introduction.rst b/bundles/routing/introduction.rst
index 17cefe75..022841a2 100644
--- a/bundles/routing/introduction.rst
+++ b/bundles/routing/introduction.rst
@@ -40,10 +40,11 @@ You can install this bundle `with composer`_ using the
 ChainRouter
 -----------
 
-The ChainRouter can replace the default symfony routing system with a chain-
+The ChainRouter can replace the default Symfony routing system with a chain-
 enabled implementation. It does not route anything on its own, but only loops
-through all chained routers. To handle standard configured symfony routes, the
-symfony default router can be put into the chain.
+through all chained routers. To handle standard configured Symfony routes, the
+Symfony default router with service name ``router.default`` can be put into
+the chain.
 
 You can configure the routing services to use in the chain, see
 :ref:`reference-config-routing-chain_routers`.
@@ -98,7 +99,6 @@ For more information on Routing in the Symfony CMF, please refer to:
 * The :doc:`configuration reference <configuration>`;
 * The documentation of the :doc:`dynamic`;
 * :doc:`dynamic_customize`;
-* The :doc:`routing introduction chapter <../../book/routing>` of the book;
 * The :doc:`routing component documentation <../../components/routing/introduction>`
   for implementation details of the routers;
 * :doc:`Sonata Admin integration <../sonata_phpcr_admin_integration/routing>`;
diff --git a/bundles/simple_cms/introduction.rst b/bundles/simple_cms/introduction.rst
index 6c08589e..1ef98593 100644
--- a/bundles/simple_cms/introduction.rst
+++ b/bundles/simple_cms/introduction.rst
@@ -16,9 +16,6 @@ some of that flexibility in favor of simplicity.
 The SimpleCmsBundle provides a solution to easily map content, routes and menu
 items based on a single tree structure in the content repository.
 
-You can find an introduction to the bundle in the
-:doc:`Getting started <../../book/simplecms>` section.
-
 The `CMF website`_ is an application using the SimpleCmsBundle.
 
 .. tip::
diff --git a/cookbook/editions/cmf_core.rst b/cookbook/editions/cmf_core.rst
index 28ae07e8..5b669028 100644
--- a/cookbook/editions/cmf_core.rst
+++ b/cookbook/editions/cmf_core.rst
@@ -10,12 +10,8 @@ incorporating CMF functionality into your application as needed.
 
 This tutorial is aimed at the experienced user who wants to learn more
 about the details of the Symfony CMF. If this is your first encounter with
-the Symfony CMF it would be a good idea to start with:
-
-* :doc:`../../book/installation` page for instructions on
-  how to quickly install the CMF (recommended for development)
-* :doc:`cmf_sandbox` for instructions on how to install
-  a demonstration sandbox.
+the Symfony CMF it would be a good idea to start with :doc:`cmf_sandbox` for
+instructions on how to install a demonstration sandbox.
 
 .. index:: RoutingBundle, CoreBundle, MenuBundle, ContentBundle, SonataBlockBundle, KnpMenuBundle, install
 
@@ -153,7 +149,7 @@ Next Steps
 ----------
 
 If you want to support multiple languages, have a look at
-:doc:`../../book/handling_multilang`.
+:doc:`../../bundles/phpcr_odm/multilang`.
 
 Then have a look at the individual :doc:`bundles <../../bundles/index>` you are
 interested in.
diff --git a/cookbook/editions/cmf_sandbox.rst b/cookbook/editions/cmf_sandbox.rst
index ac30a637..f9711ac6 100644
--- a/cookbook/editions/cmf_sandbox.rst
+++ b/cookbook/editions/cmf_sandbox.rst
@@ -15,13 +15,10 @@ This can be used to evaluate the platform or to see actual code in action,
 helping you understand the tool's internals.
 
 While it can be used as such, this sandbox does not intend to be a development
-platform. If you are looking for installation instructions for a development
-setup, please refer to:
-
-* :doc:`../../book/installation` page for instructions on
-  how to quickly install the CMF (recommended for development)
-* :doc:`cmf_core` for step-by-step installation and
-  configuration details (if you want to know all the details)
+platform. For a development setup, better set up a Symfony project starting
+from the `Symfony CMF Standard Edition`_ and then see `cmf_core` for
+step-by-step installation and configuration details (if you want to know all
+the details).
 
 .. index:: sandbox, install
 
@@ -165,6 +162,7 @@ doctrine proxies and dump the Assetic assets:
     $ php bin/console cache:clear --env=prod --no-debug
     $ php bin/console assetic:dump --env=prod --no-debug
 
+.. _`Symfony CMF Standard Edition`: https://github.com/symfony-cmf/standard-edition/
 .. _`Composer`: https://getcomposer.org
 .. _`CMF sandbox github repository`: https://github.com/symfony-cmf/cmf-sandbox
 .. _`Requirements for running Symfony2`: https://symfony.com/doc/current/reference/requirements.html
diff --git a/cookbook/map.rst.inc b/cookbook/map.rst.inc
index 76980f80..11b87d5d 100644
--- a/cookbook/map.rst.inc
+++ b/cookbook/map.rst.inc
@@ -8,6 +8,5 @@
 
 * **Editions**
 
-  * :doc:`Installing the CMF Standard Edition <../book/installation>` (in the book)
   * :doc:`editions/cmf_sandbox`
   * :doc:`editions/cmf_core`
diff --git a/index.rst b/index.rst
index 9ee8f2eb..25aa579f 100644
--- a/index.rst
+++ b/index.rst
@@ -9,7 +9,6 @@ implementing the philosophy of the `decoupled CMS`_.
     :hidden:
 
     quick_tour/index
-    book/index
     bundles/index
     components/index
     contributing/index
@@ -31,22 +30,6 @@ Symfony CMF project.
     quick_tour/the_router
     quick_tour/the_third_party_bundles
 
-Book
-----
-
-This is the Symfony CMF bible. It's the reference for any user of the CMF, who
-will typically want to keep this close at hand.
-
-.. toctree::
-    :maxdepth: 1
-
-    book/installation
-    book/simplecms
-    book/routing
-    book/database_layer
-    book/static_content
-    book/structuring_content
-
 Tutorial
 --------
 
diff --git a/quick_tour/the_big_picture.rst b/quick_tour/the_big_picture.rst
index 240332c7..6f88ef2c 100644
--- a/quick_tour/the_big_picture.rst
+++ b/quick_tour/the_big_picture.rst
@@ -78,21 +78,17 @@ extension. After that, run these commands:
     You are going to learn more about the Database layer of the Symfony CMF
     :doc:`in the next chapter of the Quick Tour <the_model>`.
 
-.. seealso::
 
-    For a complete installation guide, see the ":doc:`../book/installation`"
-    chapter of the Book.
+Running the Symfony Application
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-The Request Flow
-----------------
+Use the ``server:run`` command to run a local server for the demo.
 
-.. tip::
+Running a CMF application is the same as running any Symfony application, see
+`Configuring a Web Server`_ in the Symfony documentation.
 
-    Use the ``server:run`` command to run a local server for the demo. If you
-    use a web server like Nginx or Apache, you need to prefix the URLs
-    in this document with ``app_dev.php/`` (and the path to the ``web`` folder
-    inside the Symfony project, if that is not already the root folder of your
-    server).
+The Request Flow
+----------------
 
 Now, the Sandbox is ready to use. Navigate to the homepage
 (``http://localhost:8000/``) to see the demo:
@@ -203,6 +199,7 @@ section: ":doc:`the_model`".
 .. _`decoupled CMS`: http://decoupledcms.org
 .. _`Symfony Framework Quick Tour`: https://symfony.com/doc/current/quick_tour/the_big_picture.html
 .. _`Symfony Standard Edition`: https://github.com/symfony/symfony-standard
+.. _`Configuring a Web Server`: http://symfony.com/doc/current/setup/web_server_configuration.html
 .. _JCR: https://en.wikipedia.org/wiki/Content_repository_API_for_Java
 .. _PHPCR: http://phpcr.github.io/
 .. _KnpMenuBundle: http://knpbundles.com/KnpLabs/KnpMenuBundle
diff --git a/quick_tour/the_model.rst b/quick_tour/the_model.rst
index f887c376..c70949e5 100644
--- a/quick_tour/the_model.rst
+++ b/quick_tour/the_model.rst
@@ -172,7 +172,7 @@ When dumping the nodes again, your new page should show up under ``/cms/content/
 
 .. seealso::
 
-    See ":doc:`../book/database_layer`" if you want to know more about using
+    See ":doc:`../bundles/phpcr_odm/introduction`" if you want to know more about using
     PHPCR in a Symfony application.
 
 Final Thoughts
diff --git a/quick_tour/the_third_party_bundles.rst b/quick_tour/the_third_party_bundles.rst
index 3dc5fa45..1f3b8b05 100644
--- a/quick_tour/the_third_party_bundles.rst
+++ b/quick_tour/the_third_party_bundles.rst
@@ -10,6 +10,40 @@ chapter will walk you quickly through some other CMF bundles. Most of the
 other bundles are integrations of great existing bundles like the KnpMenuBundle_
 or SonataAdminBundle_.
 
+Initial Language Choice: Lunetics LocaleBundle
+----------------------------------------------
+
+The CMF recommends to rely on the `LuneticsLocaleBundle`_
+to handle requests to ``/`` on your website. This bundle provides the tools
+to select the best locale for the user based on various criteria.
+
+When you configure ``lunetics_locale``, it is recommended to use a parameter
+for the locales, as you need to configure the locales for other bundles
+(e.g. the CoreBundle) too.
+
+.. configuration-block::
+
+    .. code-block:: yaml
+
+        lunetics_locale:
+            allowed_locales: "%locales%"
+
+    .. code-block:: xml
+
+        <?xml version="1.0" charset="UTF-8" ?>
+        <container xmlns="http://symfony.com/schema/dic/services">
+
+            <config xmlns="http://example.org/schema/dic/lunetics_locale">
+                <allowed-locales>%locales%</allowed-locales>
+            </config>
+        </container>
+
+    .. code-block:: php
+
+        $container->loadFromExtension('lunetics_locale', array(
+            'allowed_locales' => '%locales%',
+        ));
+
 The MenuBundle
 --------------
 
@@ -207,9 +241,10 @@ You made it! Let's summarize what you've learned in the Quick Tour:
 
 I can't tell you more about the architecture and bundles of the Symfony CMF,
 but there is much much more to explore. Take a look at
-:doc:`the book <../book/index>` and get started with your first project using
+:doc:`the bundles <../bundles/index>` and get started with your first project using
 the Symfony CMF!
 
+.. _`LuneticsLocaleBundle`: https://github.com/lunetics/LocaleBundle/
 .. _KnpMenuBundle: https://github.com/KnpLabs/KnpMenuBundle
 .. _SonataBlockBundle: https://sonata-project.org/bundles/block/master/doc/index.html
 .. _SonataSeoBundle: https://sonata-project.org/bundles/seo/master/doc/index.html
diff --git a/tutorial/sonata-admin.rst b/tutorial/sonata-admin.rst
index 824f4d6b..a7a637c5 100644
--- a/tutorial/sonata-admin.rst
+++ b/tutorial/sonata-admin.rst
@@ -58,11 +58,6 @@ No translations? Uncomment the translator in the configuration file:
             ),
         ));
 
-.. tip::
-
-    See :ref:`book_handling-multilang_sonata-admin` for more information
-    on Sonata Admin and multi-language.
-
 When looking at the admin dashboard, you will notice that there is an entry
 to administrate Routes. The administration class of the RoutingBundle has
 been automatically registered. However, you do not need this in your