Permalink
Browse files

feature #3613 Javiereguiluz revamped quick tour (weaverryan)

This PR was merged into the 2.3 branch.

Discussion
----------

Javiereguiluz revamped quick tour

Hey guys!

See #3562 - this is the same, but rebased against the 2.3 branch.

| Q             | A
| ------------- | ---
| Doc fix?      | no
| New docs?     | yes
| Applies to    | 2.3+
| Fixed tickets |

Off of the top of my head (but I could be wrong), the only thing that was 2.4 specific is the version number used in the composer.phar create-project command. We could fix this in 2 different ways:

1) Don't fix it - just always keep that number updated to the latest released version. We do this similarly in other places

2) Use "@stable" as the version constraint. I don't know of any drawbacks.

Thanks!

Commits
-------

1e36cfa [quick_tour] rewording and grammar fixes noted by @xabbuh
69fdff1 [quick_tour] removed an unneeded comma
30624eb [quick_tour] more rewording and grammar fixes
0f13ce9 [quick_tour] rewording and grammar fixes suggested by @weaverryan
7c0037e Restored all the original introductions for each tutorial part
cb98a6c Restored the original line that explained how a routing file is imported from a bundle
fdc755e Grammar fixes proposed by @weaverryan and @wouterj
eca1e73 Added a more useful message for users that don't have PHP 5.4 and try to execute the server:run command
a013b11 Removed the animated GIF showing how to install Symfony
985c68f Replaced "variable" by "placeholder" when using {_format} inside a route
42bd69f Fixed the capitalization of a section heading
75be815 Minor rewording
c1ad15d Added a new headline to better structure the documentation
b16c3a2 Capitalized some sentences that come after a colon
2fdcffd When using server:run command, it's not necessary to add the `app_dev.php` controller
6afc80b Removed a wrongly inserted comma
e004661 Bundle names should not be placed in literals
38b1292 [quick_tour] removed inline links
81d6e20 [quick_tour] replaced "chapter" by "part" in some tutorial parts
50e136c [quick_tour] second pass to "the architecture" chapter
cdb7064 [quick_tour] second pass to "the controller" chapter and added a section about displaying error pages
2cd3bab [quick tour] second pass to "the view" chapter
4ad3c44 [quick_tour] second pass to the "big picture" chapter
e7dfc8b [quick_tour] simplified "the architecture" chapter
eb3fe4c [quick tour] simplified "the controller" chapter
dbbc8c2 [quick_tour] updated "the view" chapter
5b3a572 [quick_tour] finished the review of "The Big Picture" chapter
f24eabc [quick_tour] updated some screenshots
20e9fb0 [quick_tour] updated the "Controllers" section
29992cd [quick_tour] simplified the "routing" section
a84a556 [quick_tour] simplified drastically the first two sections of "The Big Picture" chapter
  • Loading branch information...
weaverryan committed Feb 27, 2014
2 parents fc0aa8b + 1e36cfa commit 9dcf467b1cfb247f6acfbc892b55fd33cbe5e02b
View
Binary file not shown.
View
BIN +804 KB (1400%) images/quick_tour/profiler.png
Binary file not shown.
View
Binary file not shown.
View
BIN +66.3 KB (220%) images/quick_tour/welcome.png
Binary file not shown.
@@ -11,13 +11,12 @@ Understanding the Directory Structure
-------------------------------------
The directory structure of a Symfony2 :term:`application` is rather flexible,
but the directory structure of the *Standard Edition* distribution reflects
the typical and recommended structure of a Symfony2 application:
but the recommended structure is as follows:
* ``app/``: The application configuration;
* ``src/``: The project's PHP code;
* ``vendor/``: The third-party dependencies;
* ``web/``: The web root directory.
* ``app/``: the application configuration;
* ``src/``: the project's PHP code;
* ``vendor/``: the third-party dependencies;
* ``web/``: the web root directory.
The ``web/`` Directory
~~~~~~~~~~~~~~~~~~~~~~
@@ -36,11 +35,10 @@ lives::
$kernel->loadClassCache();
$kernel->handle(Request::createFromGlobals())->send();
The kernel first requires the ``bootstrap.php.cache`` file, which bootstraps
the framework and registers the autoloader (see below).
Like any front controller, ``app.php`` uses a Kernel Class, ``AppKernel``, to
bootstrap the application.
The controller first bootstraps the application using a kernel class (``AppKernel``
in this case). Then, it creates the ``Request`` object using the PHP's global
variables and passes it to the kernel. The last step is to send the response
contents returned by the kernel back to the user.
.. _the-app-dir:
@@ -59,17 +57,11 @@ This class must implement two methods:
(more on this later).
Autoloading is handled automatically via `Composer`_, which means that you
can use any PHP classes without doing anything at all! If you need more flexibility,
you can extend the autoloader in the ``app/autoload.php`` file. All dependencies
can use any PHP class without doing anything at all! All dependencies
are stored under the ``vendor/`` directory, but this is just a convention.
You can store them wherever you want, globally on your server or locally
in your projects.
.. note::
If you want to learn more about Composer's autoloader, read `Composer-Autoloader`_.
Symfony also has an autoloading component - read ":doc:`/components/class_loader/class_loader`".
Understanding the Bundle System
-------------------------------
@@ -79,12 +71,13 @@ Symfony2, the :term:`bundle` system.
A bundle is kind of like a plugin in other software. So why is it called a
*bundle* and not a *plugin*? This is because *everything* is a bundle in
Symfony2, from the core framework features to the code you write for your
application. Bundles are first-class citizens in Symfony2. This gives you
the flexibility to use pre-built features packaged in third-party bundles
or to distribute your own bundles. It makes it easy to pick and choose which
features to enable in your application and optimize them the way you want.
And at the end of the day, your application code is just as *important* as
the core framework itself.
application.
Bundles are first-class citizens in Symfony2. This gives you the flexibility
to use pre-built features packaged in third-party bundles or to distribute your
own bundles. It makes it easy to pick and choose which features to enable in
your application and optimize them the way you want. And at the end of the day,
your application code is just as *important* as the core framework itself.
Registering a Bundle
~~~~~~~~~~~~~~~~~~~~
@@ -119,14 +112,14 @@ a single ``Bundle`` class that describes it::
In addition to the AcmeDemoBundle that was already talked about, notice
that the kernel also enables other bundles such as the FrameworkBundle,
DoctrineBundle, SwiftmailerBundle, and AsseticBundle bundle.
They are all part of the core framework.
DoctrineBundle, SwiftmailerBundle and AsseticBundle bundle. They are all part
of the core framework.
Configuring a Bundle
~~~~~~~~~~~~~~~~~~~~
Each bundle can be customized via configuration files written in YAML, XML, or
PHP. Have a look at the default configuration:
PHP. Have a look at the default Symfony configuration:
.. code-block:: yaml
@@ -191,9 +184,9 @@ PHP. Have a look at the default configuration:
password: "%mailer_password%"
spool: { type: memory }
Each entry like ``framework`` defines the configuration for a specific bundle.
For example, ``framework`` configures the FrameworkBundle while ``swiftmailer``
configures the SwiftmailerBundle.
Each first level entry like ``framework``, ``twig`` or ``doctrine`` defines the
configuration for a specific bundle. For example, ``framework`` configures the
FrameworkBundle while ``swiftmailer`` configures the SwiftmailerBundle.
Each :term:`environment` can override the default configuration by providing a
specific configuration file. For example, the ``dev`` environment loads the
@@ -268,7 +261,7 @@ Extending Bundles
If you follow these conventions, then you can use :doc:`bundle inheritance</cookbook/bundles/inheritance>`
to "override" files, controllers or templates. For example, you can create
a bundle - ``AcmeNewBundle`` - and specify that it overrides AcmeDemoBundle.
a bundle - AcmeNewBundle - and specify that it overrides AcmeDemoBundle.
When Symfony loads the ``AcmeDemoBundle:Welcome:index`` controller, it will
first look for the ``WelcomeController`` class in AcmeNewBundle and, if
it doesn't exist, then look inside AcmeDemoBundle. This means that one bundle
@@ -296,8 +289,9 @@ each request? The speed is partly due to its cache system. The application
configuration is only parsed for the very first request and then compiled down
to plain PHP code stored in the ``app/cache/`` directory. In the development
environment, Symfony2 is smart enough to flush the cache when you change a
file. But in the production environment, it is your responsibility to clear
the cache when you update your code or change its configuration.
file. But in the production environment, to speed things up, it is your
responsibility to clear the cache when you update your code or change its
configuration.
When developing a web application, things can go wrong in many ways. The log
files in the ``app/logs/`` directory tell you everything about the requests
@@ -336,4 +330,3 @@ topics now? Look no further - go to the official :doc:`/book/index` and pick
any topic you want.
.. _Composer: http://getcomposer.org
.. _`Composer-Autoloader`: http://getcomposer.org/doc/01-basic-usage.md#autoloading
Oops, something went wrong.

0 comments on commit 9dcf467

Please sign in to comment.