fixing php-fluent-di syntax highlighting, adding more files

Signed-off-by: RJ Garcia <rj@bighead.net>

Author: ragboyjr

_build/conf.py

@@ -106,6 +106,7 @@
 lexers['php-annotations'] = PhpLexer(startinline=True)
 lexers['php-standalone'] = PhpLexer(startinline=True)
 lexers['php-symfony'] = PhpLexer(startinline=True)
+lexers['php-fluent-di'] = PhpLexer(startinline=True)
 lexers['rst'] = RstLexer()
 lexers['varnish3'] = CLexer()
 lexers['varnish4'] = CLexer()

components/dependency_injection.rst

@@ -317,7 +317,7 @@ config files:
                 ->args(['%mailer.transport%']);
 
             $container->set('newsletter_manager', 'NewsletterManager')
-                ->call('setMailer', ref('mailer'));
+                ->call('setMailer', [ref('mailer')]);
         };
 
 

service_container.rst

@@ -936,7 +936,7 @@ But, if you *do* need to make a service public, override the ``public`` setting:
             </services>
         </container>
 
-    .. code-block:: php-fuent-di
+    .. code-block:: php-fluent-di
 
         // config/services.php
 

service_container/3.3-di-changes.rst

@@ -81,6 +81,25 @@ what the file looks like in Symfony 4):
             </services>
         </container>
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            $container = $configurator->services()
+                ->defaults()
+                ->autowire()
+                ->autoconfigure()
+                ->private();
+
+            $container->load('App\\', '../src/*')
+                ->exclude('../src/{Entity,Migrations,Tests}');
+
+            $container->load('App\\Controller\\', '../src/Controller')
+                ->tag('controller.service_arguments');
+        };
+
 This small bit of configuration contains a paradigm shift of how services
 are configured in Symfony.
 
@@ -130,6 +149,18 @@ thanks to the following config:
             </services>
         </container>
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+
+            $container->load('App\\', '../src/*')
+                ->exclude('../src/{Entity,Migrations,Tests}');
+        };
+
 This means that every class in ``src/`` is *available* to be used as a
 service. And thanks to the ``_defaults`` section at the top of the file, all of
 these services are **autowired** and **private** (i.e. ``public: false``).
@@ -329,6 +360,19 @@ The third big change is that, in a new Symfony 3.3 project, your controllers are
         $definition->addTag('controller.service_arguments');
         $this->registerClasses($definition, 'App\\Controller\\', '../src/Controller/*');
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+
+            $container->load('App\\Controller\\', '../src/Controller')
+                ->tag('controller.service_arguments');
+        };
+
+
 But, you might not even notice this. First, your controllers *can* still extend
 the same base controller class (``AbstractController``).
 This means you have access to all of the same shortcuts as before. Additionally,
@@ -466,6 +510,20 @@ inherited from an abstract definition:
             </services>
         </container>
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Domain\LoaderInterface;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+
+            $container->instanceof(LoaderInterface::class
+                ->public()
+                ->tag('app.domain_loader');
+        };
+
 What about Performance
 ----------------------
 

service_container/autowiring.rst

@@ -116,6 +116,23 @@ both services:
         $container->autowire(Rot13Transformer::class)
             ->setPublic(false);
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        return function(ContainerConfigurator $configurator) {
+            $container = $configurator->services()
+                ->defaults()
+                ->autowire()
+                ->autoconfigure()
+                ->private();
+
+            $container->set(TwitterClient::class)
+                ->autowire(); // redundant thanks to defaults, but value is overridable on each service
+            $container->set(Rot13Transformer::class)
+                ->autowire();
+        };
+
+
 Now, you can use the ``TwitterClient`` service immediately in a controller::
 
     namespace App\Controller;
@@ -237,6 +254,22 @@ adding a service alias:
             ->setPublic(false);
         $container->setAlias(Rot13Transformer::class, 'app.rot13.transformer');
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Util\Rot13Transformer;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+
+            $container->set('app.rot13.transformer', Rot13Transformer::class)
+                ->autowire()
+                ->private();
+            $container->alias(Rot13Transformer::class, 'app.rot13.transformer');
+        };
+
+
 This creates a service "alias", whose id is ``App\Util\Rot13Transformer``.
 Thanks to this, autowiring sees this and uses it whenever the ``Rot13Transformer``
 class is type-hinted.
@@ -332,6 +365,21 @@ To fix that, add an :ref:`alias <service-autowiring-alias>`:
         $container->autowire(Rot13Transformer::class);
         $container->setAlias(TransformerInterface::class, Rot13Transformer::class);
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Util\Rot13Transformer;
+        use App\Util\TransformerInterface;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+
+            $container->set(Rot13Transformer::class);
+            $container->alias(TransformerInterface::class, Rot13Transformer::class);
+        };
+
+
 Thanks to the ``App\Util\TransformerInterface`` alias, the autowiring subsystem
 knows that the ``App\Util\Rot13Transformer`` service should be injected when
 dealing with the ``TransformerInterface``.
@@ -429,6 +477,28 @@ that alias:
             //->setArgument('$transformer', new Reference(UppercaseTransformer::class))
         ;
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Util\Rot13Transformer;
+        use App\Util\UppercaseTransformer;
+        use App\Util\TransformerInterface;
+        use App\Service\TwitterClient;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+        use function Symfony\Component\DependencyInjection\Loader\Configurator\ref;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+
+            $container->set(Rot13Transformer::class);
+            $container->set(UppercaseTransformer::class);
+            $container->alias(TransformerInterface::class, Rot13Transformer::class);
+
+            $container->set(TwitterClient::class)
+                ->autowire()
+                // ->arg('$transformer', ref(UppercaseTransformer::class))
+        };
+
 Thanks to the ``App\Util\TransformerInterface`` alias, any argument type-hinted
 with this interface will be passed the ``App\Util\Rot13Transformer`` service.
 But, you can also manually wire the *other* service by specifying the argument

service_container/calls.rst

@@ -71,3 +71,17 @@ To configure the container to call the ``setLogger`` method, use the ``calls`` k
 
         $container->register(MessageGenerator::class)
             ->addMethodCall('setLogger', [new Reference('logger')]);
+
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Service\MessageGenerator;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+        use function Symfony\Component\DependencyInjection\Loader\Configurator\ref;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+            $container->set(MessageGenerator::class)
+                ->call('setLogger', [ref('logger')]);
+        };
+

service_container/configurators.rst

@@ -184,6 +184,26 @@ all the classes are already loaded as services. All you need to do is specify th
         $container->getDefinition(GreetingCardManager::class)
             ->setConfigurator([new Reference(EmailConfigurator::class), 'configure']);
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Mail\EmailConfigurator;
+        use App\Mail\GreetingCardManager;
+        use App\Mail\NewsletterManager;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+        use function Symfony\Component\DependencyInjection\Loader\Configurator\ref;
+
+        return function(ContainerConfigurator $configurator) {
+            $container = $configurator->services();
+
+            $container->load('App\', '../src/*');
+            $container->set(NewsletterManager::class)
+                ->configurator(ref(EmailConfigurator::class), 'configure');
+
+            $container->set(GreetingCardManager::class)
+                ->configurator(ref(EmailConfigurator::class), 'configure');
+        };
+
 The traditional configurator syntax in YAML files used an array to define
 the service id and the method name:
 

service_container/expression_language.rst

@@ -62,6 +62,23 @@ to another service: ``App\Mailer``. One way to do this is with an expression:
         $container->autowire(Mailer::class)
             ->addArgument(new Expression('service("App\\\\Mail\\\\MailerConfiguration").getMailerMethod()'));
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Mail\MailerConfiguration;
+        use App\Mailer;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+        use function Symfony\Component\DependencyInjection\Loader\Configurator\expr;
+
+        return function(ContainerConfigurator $configurator) {
+            // ...
+            $container->set(MailerConfiguration::class);
+
+            $container->set(Mailer::class)
+                ->args([expr(sprintf('service(%s).getMailerMethod()', MailerConfiguration::class))]);
+        };
+
+
 To learn more about the expression language syntax, see :doc:`/components/expression_language/syntax`.
 
 In this context, you have access to 2 functions:
@@ -110,5 +127,19 @@ via a ``container`` variable. Here's another example:
                 "container.hasParameter('some_param') ? parameter('some_param') : 'default_value'"
             ));
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Mailer;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+        use function Symfony\Component\DependencyInjection\Loader\Configurator\expr;
+
+        return function(ContainerConfigurator $configurator) {
+            $container = $configurator->services();
+
+            $container->set(Mailer::class)
+                ->args([expr("container.hasParameter('some_param') ? parameter('some_param') : 'default_value'")]);
+        };
+
 Expressions can be used in ``arguments``, ``properties``, as arguments with
 ``configurator`` and as arguments to ``calls`` (method calls).

service_container/factories.rst

@@ -77,6 +77,21 @@ configure the service container to use the
             // call the static method
             ->setFactory([NewsletterManagerStaticFactory::class, 'createNewsletterManager']);
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Email\NewsletterManager;
+        use App\Email\NewsletterManagerStaticFactory;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            $container = $configurator->services();
+
+            $container->set(NewsletterManager::class)
+                ->factory([NewsletterManagerStaticFactory::class, 'createNewsletterManager']);
+        };
+
+
 .. note::
 
     When using a factory to create services, the value chosen for class
@@ -143,6 +158,21 @@ Configuration of the service container then looks like this:
                 'createNewsletterManager',
             ]);
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Email\NewsletterManager;
+        use App\Email\NewsletterManagerFactory;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+        use function Symfony\Component\DependencyInjection\Loader\Configurator\ref;
+
+        return function(ContainerConfigurator $configurator) {
+            $container = $configurator->services();
+
+            $container->set(NewsletterManager::class)
+                ->factory([ref(NewsletterManagerFactory::class), 'createNewsletterManager']);
+        };
+
 .. note::
 
     The traditional configuration syntax in YAML files used an array to define
@@ -216,3 +246,20 @@ example takes the ``templating`` service as an argument:
                 new Reference(NewsletterManagerFactory::class),
                 'createNewsletterManager',
             ]);
+
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use App\Email\NewsletterManager;
+        use App\Email\NewsletterManagerFactory;
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+        use function Symfony\Component\DependencyInjection\Loader\Configurator\ref;
+
+        return function(ContainerConfigurator $configurator) {
+            $container = $configurator->services();
+
+            $container->set(NewsletterManager::class)
+                ->args([ref('templating')])
+                ->factory([ref(NewsletterManagerFactory::class), 'createNewsletterManager']);
+        };
+

service_container/import.rst

@@ -99,6 +99,15 @@ To import this file, use the ``imports`` key from a file that *is* loaded:
         // config/services.php
         $loader->import('services/mailer.php');
 
+    .. code-block:: php-fluent-di
+
+        // config/services.php
+        use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+
+        return function(ContainerConfigurator $configurator) {
+            $configurator->import('services/mailer.php');
+        };
+
 The ``resource`` location, for files, is either a relative path from the
 current file or an absolute path.