symfony
diff --git a/‎http_fundamentals.rst
Lines changed: 0 additions & 151 deletions b/‎http_fundamentals.rst
Lines changed: 0 additions & 151 deletions
@@ -368,157 +368,6 @@ It's that easy! To review:
 
 * The HTTP headers and content of the ``Response`` object are sent back to the client.
 
-A Symfony Request in Action
-~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Without diving into too much detail, here is this process in action. Suppose
-you want to add a ``/contact`` page to your Symfony application. First, start
-by adding an entry for ``/contact`` to your routing configuration file:
-
-.. configuration-block::
-
-    .. code-block:: yaml
-
-        # app/config/routing.yml
-        contact:
-            path:     /contact
-            defaults: { _controller: AppBundle:Main:contact }
-
-    .. code-block:: xml
-
-
<!-- app/config/routing.xml -->        <!-- app/config/routing.xml -->
-        <?xml version="1.0" encoding="UTF-8" ?>
-        <routes xmlns="http://symfony.com/schema/routing"
-            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-            xsi:schemaLocation="http://symfony.com/schema/routing
-                http://symfony.com/schema/routing/routing-1.0.xsd">
-
-            <route id="contact" path="/contact">
-                <default key="_controller">AppBundle:Main:contact</default>
-            </route>
-        </routes>
-
-    .. code-block:: php
-
-        // app/config/routing.php
-        use Symfony\Component\Routing\Route;
-        use Symfony\Component\Routing\RouteCollection;
-
-        $collection = new RouteCollection();
-        $collection->add('contact', new Route('/contact', array(
-            '_controller' => 'AppBundle:Main:contact',
-        )));
-
-        return $collection;
-
-When someone visits the ``/contact`` page, this route is matched, and the
-specified controller is executed. As you'll learn in the
-:ref:`routing chapter <controller-string-syntax>`, the ``AppBundle:Main:contact``
-string is a short syntax that points to a specific controller - ``contactAction()`` -
-inside a controller class called - ``MainController``::
-
-    // src/AppBundle/Controller/MainController.php
-    namespace AppBundle\Controller;
-
-    use Symfony\Component\HttpFoundation\Response;
-
-    class MainController
-    {
-        public function contactAction()
-        {
-            return new Response('<h1>Contact us!</h1>');
-        }
-    }
-
-In this example, the controller creates a
-:class:`Symfony\\Component\\HttpFoundation\\Response` object with the HTML
-``<h1>Contact us!</h1>``. In the :doc:`Controller chapter </book/controller>`,
-you'll learn how a controller can render templates, allowing your "presentation"
-code (i.e. anything that actually writes out HTML) to live in a separate
-template file. This frees up the controller to worry only about the hard
-stuff: interacting with the database, handling submitted data, or sending
-email messages.
-
-.. _symfony2-build-your-app-not-your-tools:
-
-Symfony: Build your App, not your Tools
----------------------------------------
-
-You now know that the goal of any app is to interpret each incoming request
-and create an appropriate response. As an application grows, it becomes more
-difficult to keep your code organized and maintainable. Invariably, the same
-complex tasks keep coming up over and over again: persisting things to the
-database, rendering and reusing templates, handling form submissions, sending
-emails, validating user input and handling security.
-
-The good news is that none of these problems is unique. Symfony provides
-a framework full of tools that allow you to build your application, not your
-tools. With Symfony, nothing is imposed on you: you're free to use the full
-Symfony Framework, or just one piece of Symfony all by itself.
-
-.. index::
-    single: Symfony Components
-
-.. _standalone-tools-the-symfony2-components:
-
-Standalone Tools: The Symfony *Components*
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-So what *is* Symfony? First, Symfony is a collection of over twenty independent
-libraries that can be used inside *any* PHP project. These libraries, called
-the *Symfony Components*, contain something useful for almost any situation,
-regardless of how your project is developed. To name a few:
-
-:doc:`HttpFoundation </components/http_foundation/introduction>`
-    Contains the ``Request`` and ``Response`` classes, as well as other classes for
-    handling sessions and file uploads.
-
-:doc:`Routing </components/routing/introduction>`
-    Powerful and fast routing system that allows you to map a specific URI
-    (e.g. ``/contact``) to information about how that request should be handled (e.g.
-    that the ``contactAction()`` controller method should be executed).
-
-:doc:`Form </components/form/introduction>`
-    A full-featured and flexible framework for creating forms and handling form
-    submissions.
-
-`Validator`_
-    A system for creating rules about data and then validating whether or not
-    user-submitted data follows those rules.
-
-:doc:`Templating </components/templating/introduction>`
-    A toolkit for rendering templates, handling template inheritance (i.e. a
-    template is decorated with a layout) and performing other common template tasks.
-
-:doc:`Security </components/security/introduction>`
-    A powerful library for handling all types of security inside an application.
-
-:doc:`Translation </components/translation/introduction>`
-    A framework for translating strings in your application.
-
-Each one of these components is decoupled and can be used in *any* PHP project,
-regardless of whether or not you use the Symfony Framework. Every part is
-made to be used if needed and replaced when necessary.
-
-.. _the-full-solution-the-symfony2-framework:
-
-The Full Solution: The Symfony *Framework*
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-So then, what *is* the Symfony *Framework*? The *Symfony Framework* is
-a PHP library that accomplishes two distinct tasks:
-
-#. Provides a selection of components (i.e. the Symfony Components) and
-   third-party libraries (e.g. `Swift Mailer`_ for sending emails);
-
-#. Provides sensible configuration and a "glue" library that ties all of these
-   pieces together.
-
-The goal of the framework is to integrate many independent tools in order
-to provide a consistent experience for the developer. Even the framework
-itself is a Symfony bundle (i.e. a plugin) that can be configured or replaced
-entirely.
-
 Symfony provides a powerful set of tools for rapidly developing web applications
 without imposing on your application. Normal users can quickly start development
 by using a Symfony distribution, which provides a project skeleton with