updated configuration

Author: fabpot

guides/bundles/configuration.rst

@@ -88,7 +88,7 @@ that extends
 
  class HelloExtension extends Extension
  {
- public function configLoad($config, ContainerBuilder $container)
+ public function load(array $configs, ContainerBuilder $container)
  {
  // ...
  }
@@ -109,15 +109,15 @@ that extends
  }
  }
 
-The previous class defines a ``hello:config`` namespace, usable in any
-configuration file:
+The previous class defines a ``hello`` namespace, usable in any configuration
+file:
 
 .. configuration-block::
 
  .. code-block:: yaml
 
  # app/config/config.yml
- hello.config: ~
+ hello: ~
 
  .. code-block:: xml
 
@@ -137,20 +137,20 @@ configuration file:
  .. code-block:: php
 
  // app/config/config.php
- $container->loadFromExtension('hello', 'config', array());
+ $container->loadFromExtension('hello', array());
 
-.. note::
+.. tip::
 
- You can create as many ``xxxLoad()`` methods as you want to define more
- configuration blocks for your extension.
+ Your extension code is always called, even if the user does not provide
+ any configuration. In that case, the array of configurations will be empty
+ and you can still provide some sensible defaults if you want.
 
 Parsing a Configuration
 ~~~~~~~~~~~~~~~~~~~~~~~
 
-Whenever a user includes the ``hello.config`` namespace in a configuration
-file, the ``configLoad()`` method of your extension is called and the
-configuration is passed as an array (Symfony2 automatically converts XML and
-YAML to an array).
+Whenever a user includes the ``hello`` namespace in a configuration file, it
+is added to an array of configurations and passed to the ``load()`` method of
+your extension (Symfony2 automatically converts XML and YAML to an array).
 
 So, given the following configuration:
 
@@ -159,7 +159,7 @@ So, given the following configuration:
  .. code-block:: yaml
 
  # app/config/config.yml
- hello.config:
+ hello:
  foo: foo
  bar: bar
 
@@ -182,24 +182,26 @@ So, given the following configuration:
  .. code-block:: php
 
  // app/config/config.php
- $container->loadFromExtension('hello', 'config', array(
+ $container->loadFromExtension('hello', array(
  'foo' => 'foo',
  'bar' => 'bar',
  ));
 
 The array passed to your method looks like the following::
 
  array(
- 'foo' => 'foo',
- 'bar' => 'bar',
+ array(
+ 'foo' => 'foo',
+ 'bar' => 'bar',
+ )
  )
 
-Within ``configLoad()``, the ``$container`` variable refers to a container
-that only knows about this namespace configuration. You can manipulate it the
-way you want to add services and parameters. The first time the method is
-called, the container only knows about global parameters. For subsequent
-calls, it contains the configuration as defined by previous calls. So, the
-method needs to merge new configuration settings with old ones::
+Within ``load()``, the ``$container`` variable refers to a container that only
+knows about this namespace configuration. You can manipulate it the way you
+want to add services and parameters. The first time the method is called, the
+container only knows about global parameters. For subsequent calls, it
+contains the configuration as defined by previous calls. So, the method needs
+to merge new configuration settings with old ones::
 
  // only load default services and parameters once
  if (!$container->hasDefinition('xxxxx')) {
@@ -235,21 +237,20 @@ When creating an extension, follow these simple conventions:
 * The extension must be stored in the ``DependencyInjection`` sub-namespace;
 
 * The extension must be named after the bundle name and suffixed with
- ``Extension`` (``HelloExtension`` for ``HelloBundle``) -- when you provide
- several extensions for a single bundle, just end them with ``Extension``;
+ ``Extension`` (``SensioHelloExtension`` for ``SensioHelloBundle``);
 
-* The alias must be unique and named after the bundle name (``hello`` for
- ``HelloBundle`` or ``sensio.social.blog`` for ``Sensio\Social\BlogBundle``);
+* The alias must be unique and named after the bundle name (``sensio_blog``
+ for ``SensioBlogBundle``);
 
 * The extension should provide an XSD schema.
 
 If you follow these simple conventions, your extensions will be registered
 automatically by Symfony2. If not, override the Bundle
-:method:`Symfony\\Component\\HttpKernel\\Bundle\\Bundle::registerExtensions` method::
+:method:`Symfony\\Component\\HttpKernel\\Bundle\\Bundle::build` method::
 
  class HelloBundle extends Bundle
  {
- public function registerExtensions(ContainerBuilder $container)
+ public function build(ContainerBuilder $container)
  {
  // register the extension(s) found in DependencyInjection/ directory
  parent::registerExtensions($container);
@@ -261,29 +262,3 @@ automatically by Symfony2. If not, override the Bundle
 
 .. index::
  single: Bundles; Default Configuration
-
-Default Configuration
-~~~~~~~~~~~~~~~~~~~~~
-
-As stated before, the user of the bundle should include the ``hello.config``
-namespace in a configuration file for your extension code to be called. But you
-can automatically register a default configuration by overriding the Bundle
-:method:`Symfony\\Component\\HttpKernel\\Bundle\\Bundle::registerExtensions`
-method::
-
- class HelloBundle extends Bundle
- {
- public function registerExtensions(ContainerBuilder $container)
- {
- // will register the HelloBundle extension(s) found in DependencyInjection/ directory
- parent::registerExtensions($container);
-
- // load some defaults
- $container->loadFromExtension('hello', 'config', array(/* your default config for the hello.config namespace */));
- }
- }
-
-.. caution::
-
- Symfony2 tries to be as explicit as possible. So, registering a default
- configuration automatically is probably not a good idea.

guides/cache/http.rst

@@ -644,7 +644,7 @@ route:
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.symfony-project.org/schema/routing http://www.symfony-project.org/schema/routing/routing-1.0.xsd">
 
- <import resource="FrameworkBundle/Resources/config/routing/internal.xml" prefix="/_internal" />
+ <import resource="@FrameworkBundle/Resources/config/routing/internal.xml" prefix="/_internal" />
  </routes>
 
  .. code-block:: php
@@ -653,7 +653,7 @@ route:
  use Symfony\Component\Routing\RouteCollection;
  use Symfony\Component\Routing\Route;
 
- $collection->addCollection($loader->import('FrameworkBundle/Resources/config/routing/internal.xml', '/_internal'));
+ $collection->addCollection($loader->import('@FrameworkBundle/Resources/config/routing/internal.xml', '/_internal'));
 
  return $collection;
 
@@ -694,7 +694,7 @@ To use ESI, be sure to enable it in your application configuration:
  .. code-block:: yaml
 
  # app/config/config.yml
- app.config:
+ framework:
  # ...
  esi:
  enabled: true
@@ -704,15 +704,15 @@ To use ESI, be sure to enable it in your application configuration:
  <!-- app/config/config.xml -->
  <?xml version="1.0" encoding="UTF-8" ?>
 
- <app:config charset="UTF-8">
+ <framework:config charset="UTF-8">
  <!-- ... -->
- <app:esi enabled="true" />
- </app:config>
+ <framework:esi enabled="true" />
+ </framework:config>
 
  .. code-block:: php
 
  // app/config/config.php
- $container->loadFromExtension('app', 'config', array(
+ $container->loadFromExtension('framework', array(
  // ...
  'esi' => array(
  'enabled' => true,

guides/doctrine/dbal/configuration.rst

@@ -11,11 +11,12 @@ example:
 .. code-block:: yaml
 
  # app/config/config.yml
- doctrine.dbal:
- driver: pdo_mysql
- dbname: Symfony2
- user: root
- password: null
+ doctrine:
+ dbal:
+ driver: pdo_mysql
+ dbname: Symfony2
+ user: root
+ password: null
 
 The DoctrineBundle supports all parameters that all the default doctrine drivers
 accept, converted to the XML or YAML naming standards that Symfony enforces.
@@ -28,45 +29,48 @@ further:
 
  .. code-block:: yaml
 
- doctrine.dbal:
- dbname: database
- host: localhost
- port: 1234
- user: user
- password: secret
- driver: pdo_mysql
- driver_class: MyNamespace\MyDriverImpl
- options:
- foo: bar
- path: %kernel.data_dir%/data.sqlite
- memory: true
- unix_socket: /tmp/mysql.sock
- wrapper_class: MyDoctrineDbalConnectionWrapper
- charset: UTF-8
- logging: %kernel.debug%
- platform_service: MyOwnDatabasePlatformService
+ doctrine:
+ dbal:
+ dbname: database
+ host: localhost
+ port: 1234
+ user: user
+ password: secret
+ driver: pdo_mysql
+ driver_class: MyNamespace\MyDriverImpl
+ options:
+ foo: bar
+ path: %kernel.data_dir%/data.sqlite
+ memory: true
+ unix_socket: /tmp/mysql.sock
+ wrapper_class: MyDoctrineDbalConnectionWrapper
+ charset: UTF-8
+ logging: %kernel.debug%
+ platform_service: MyOwnDatabasePlatformService
 
  .. code-block:: xml
 
  <!-- xmlns:doctrine="http://www.symfony-project.org/schema/dic/doctrine" -->
  <!-- xsi:schemaLocation="http://www.symfony-project.org/schema/dic/doctrine http://www.symfony-project.org/schema/dic/doctrine/doctrine-1.0.xsd"> -->
 
- <doctrine:dbal
- dbname="database"
- host="localhost"
- port="1234"
- user="user"
- password="secret"
- driver="pdo_mysql"
- driver-class="MyNamespace\MyDriverImpl"
- path="%kernel.data_dir%/data.sqlite"
- memory="true"
- unix-socket="/tmp/mysql.sock"
- wrapper-class="MyDoctrineDbalConnectionWrapper"
- charset="UTF-8"
- logging="%kernel.debug%"
- platform-service="MyOwnDatabasePlatformService"
- />
+ <doctrine:config>
+ <doctrine:dbal
+ dbname="database"
+ host="localhost"
+ port="1234"
+ user="user"
+ password="secret"
+ driver="pdo_mysql"
+ driver-class="MyNamespace\MyDriverImpl"
+ path="%kernel.data_dir%/data.sqlite"
+ memory="true"
+ unix-socket="/tmp/mysql.sock"
+ wrapper-class="MyDoctrineDbalConnectionWrapper"
+ charset="UTF-8"
+ logging="%kernel.debug%"
+ platform-service="MyOwnDatabasePlatformService"
+ />
+ </doctrine:config>
 
 There are also a bunch of dependency injection container parameters
 that allow you to specify which classes are used (with their default values):
@@ -88,19 +92,20 @@ can also be specified in the connections subkeys.
 
 .. code-block:: yaml
 
- doctrine.dbal:
- default_connection: default
- connections:
- default:
- dbname: Symfony2
- user: root
- password: null
- host: localhost
- customer:
- dbname: customer
- user: root
- password: null
- host: localhost
+ doctrine:
+ dbal:
+ default_connection: default
+ connections:
+ default:
+ dbname: Symfony2
+ user: root
+ password: null
+ host: localhost
+ customer:
+ dbname: customer
+ user: root
+ password: null
+ host: localhost
 
 If you have defined multiple connections you can use the
 ``$this->get('doctrine.dbal.[connectionname]_connection)``
@@ -119,4 +124,4 @@ connection name that you want get::
  }
  }
 
-.. _documentation: http://www.doctrine-project.org/projects/dbal/2.0/docs/en
+.. _documentation: http://www.doctrine-project.org/projects/dbal/2.0/docs/en

guides/doctrine/dbal/overview.rst

@@ -19,11 +19,12 @@ To get started you just need to enable and configure the DBAL:
 
  # app/config/config.yml
 
- doctrine.dbal:
- driver: pdo_mysql
- dbname: Symfony2
- user: root
- password: null
+ doctrine:
+ dbal:
+ driver: pdo_mysql
+ dbname: Symfony2
+ user: root
+ password: null
 
 You can then access the Doctrine DBAL connection by accessing the
 ``database_connection`` service::