Implement PluginProvider and awesome plugin support (#150)

* First look how to add FakeIpPlugin

* Applied changes from StyleCI

* Typo

* Adding plugin support

* Adding PluginProvider

* Applied changes from StyleCI

* Fixed the tests

* Applied changes from StyleCI

* Added docs

* Fixed #151

Author: Nyholm

Changelog.md

@@ -10,6 +10,7 @@ Version 5 does only support Symfony 3.3+ and PHP7. We dropped some complexity an
 
 - Support for Geocoder 4.0
 - Provider factories
+- Support for plugins
 
 ### Changed
 
@@ -23,4 +24,4 @@ Version 5 does only support Symfony 3.3+ and PHP7. We dropped some complexity an
 
 ## Version 4.1.0
 
-No changelog before this version
+No changelog before this version

DataCollector/GeocoderDataCollector.php

@@ -10,6 +10,7 @@
 
 namespace Bazinga\GeocoderBundle\DataCollector;
 
+use Bazinga\GeocoderBundle\Plugin\ProfilingPlugin;
 use Symfony\Component\HttpFoundation\Request;
 use Symfony\Component\HttpFoundation\Response;
 use Symfony\Component\HttpKernel\DataCollector\DataCollector;
@@ -20,7 +21,7 @@
 class GeocoderDataCollector extends DataCollector
 {
     /**
-     * @var ProfilingProvider[]
+     * @var ProfilingPlugin[]
      */
     private $instances = [];
 
@@ -35,6 +36,10 @@ public function __construct()
      */
     public function collect(Request $request, Response $response, \Exception $exception = null)
     {
+        if (!empty($this->data['queries'])) {
+            // To avoid collection more that once.
+            return;
+        }
         foreach ($this->instances as $instance) {
             foreach ($instance->getQueries() as $query) {
                 $query['query'] = $this->cloneVar($query['query']);
@@ -90,9 +95,9 @@ public function getProviderQueries($provider): array
     }
 
     /**
-     * @param ProfilingProvider $instance
+     * @param ProfilingPlugin $instance
      */
-    public function addInstance(ProfilingProvider $instance)
+    public function addInstance(ProfilingPlugin $instance)
     {
         $this->instances[] = $instance;
         $this->data['providers'][] = $instance->getName();

DependencyInjection/BazingaGeocoderExtension.php

@@ -10,10 +10,17 @@
 
 namespace Bazinga\GeocoderBundle\DependencyInjection;
 
-use Bazinga\GeocoderBundle\EventListener\FakeRequestListener;
+use Bazinga\GeocoderBundle\DataCollector\GeocoderDataCollector;
+use Bazinga\GeocoderBundle\Plugin\FakeIpPlugin;
+use Bazinga\GeocoderBundle\Plugin\ProfilingPlugin;
+use Bazinga\GeocoderBundle\ProviderFactory\PluginProviderFactory;
 use Bazinga\GeocoderBundle\ProviderFactory\ProviderFactoryInterface;
+use Geocoder\Plugin\Plugin\CachePlugin;
+use Geocoder\Plugin\Plugin\LimitPlugin;
+use Geocoder\Plugin\Plugin\LocalePlugin;
+use Geocoder\Plugin\Plugin\LoggerPlugin;
+use Geocoder\Plugin\PluginProvider;
 use Geocoder\Provider\Cache\ProviderCache;
-use Geocoder\Provider\Provider;
 use Symfony\Component\Config\Definition\Processor;
 use Symfony\Component\Config\FileLocator;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
@@ -38,41 +45,111 @@ public function load(array $configs, ContainerBuilder $container)
         if (true === $config['profiling']['enabled']) {
             $loader->load('profiling.yml');
         }
-        $this->loadProviders($container, $config);
 
         if ($config['fake_ip']['enabled']) {
-            $definition = $container->getDefinition(FakeRequestListener::class);
-            $definition->replaceArgument(0, $config['fake_ip']['ip']);
+            $definition = $container->getDefinition(FakeIpPlugin::class);
+            $definition->replaceArgument(1, $config['fake_ip']['ip']);
         } else {
-            $container->removeDefinition(FakeRequestListener::class);
+            $container->removeDefinition(FakeIpPlugin::class);
         }
+
+        $this->loadProviders($container, $config);
     }
 
     private function loadProviders(ContainerBuilder $container, array $config)
     {
         foreach ($config['providers'] as $providerName => $providerConfig) {
             $factoryService = $container->getDefinition($providerConfig['factory']);
             $factoryClass = $factoryService->getClass() ?: $providerConfig['factory'];
-            if (!(is_a($factoryClass, ProviderFactoryInterface::class))) {
-                //throw new \LogicException(sprintf('Provider factory "%s" must implement ProviderFactoryInterface', $providerConfig['factory']));
+            if (!class_implements($factoryClass, ProviderFactoryInterface::class)) {
+                throw new \LogicException(sprintf('Provider factory "%s" must implement ProviderFactoryInterface', $providerConfig['factory']));
             }
             $factoryClass::validate($providerConfig['options'], $providerName);
 
             // See if any option has a service reference
             $providerConfig['options'] = $this->findReferences($providerConfig['options']);
 
             $serviceId = 'bazinga_geocoder.provider.'.$providerName;
-            $def = $container->register($serviceId, Provider::class);
-            $def->setFactory([new Reference($providerConfig['factory']), 'createProvider'])
+            $plugins = $this->configureProviderPlugins($container, $providerConfig, $serviceId);
+
+            $def = $container->register($serviceId, PluginProvider::class)
+                ->setFactory([PluginProviderFactory::class, 'createPluginProvider'])
+                ->addArgument($plugins)
+                ->addArgument(new Reference($providerConfig['factory']))
                 ->addArgument($providerConfig['options']);
 
             $def->addTag('bazinga_geocoder.provider');
             foreach ($providerConfig['aliases'] as $alias) {
                 $container->setAlias($alias, $serviceId);
             }
+        }
+    }
+
+    /**
+     * Configure plugins for a client.
+     *
+     * @param ContainerBuilder $container
+     * @param array            $config
+     * @param string           $providerServiceId
+     *
+     * @return array
+     */
+    public function configureProviderPlugins(ContainerBuilder $container, array $config, string $providerServiceId): array
+    {
+        $plugins = [];
+        foreach ($config['plugins'] as $plugin) {
+            $plugins[] = $plugin['id'];
+        }
+
+        if (isset($config['cache']) || isset($config['cache_lifetime'])) {
+            if (null === $cacheServiceId = $config['cache']) {
+                if (!$container->has('app.cache')) {
+                    throw new \LogicException('You need to specify a service for cache.');
+                }
+                $cacheServiceId = 'app.cache';
+            }
+            $plugins[] = $providerServiceId.'.cache';
+            $container->register($providerServiceId.'.cache', CachePlugin::class)
+                ->setPublic(false)
+                ->setArguments([new Reference($cacheServiceId), (int) $config['cache_lifetime']]);
+        }
 
-            $this->configureCache($container, $serviceId, $providerConfig);
+        if (isset($config['limit'])) {
+            $plugins[] = $providerServiceId.'.limit';
+            $container->register($providerServiceId.'.limit', LimitPlugin::class)
+                ->setPublic(false)
+                ->setArguments([(int) $config['limit']]);
         }
+
+        if (isset($config['locale'])) {
+            $plugins[] = $providerServiceId.'.locale';
+            $container->register($providerServiceId.'.locale', LocalePlugin::class)
+                ->setPublic(false)
+                ->setArguments([$config['locale']]);
+        }
+
+        if (isset($config['logger'])) {
+            $plugins[] = $providerServiceId.'.logger';
+            $container->register($providerServiceId.'.logger', LoggerPlugin::class)
+                ->setPublic(false)
+                ->setArguments([new Reference($config['logger'])]);
+        }
+
+        if ($container->has(FakeIpPlugin::class)) {
+            $plugins[] = FakeIpPlugin::class;
+        }
+
+        if ($container->has(GeocoderDataCollector::class)) {
+            $plugins[] = $providerServiceId.'.profiler';
+            $container->register($providerServiceId.'.profiler', ProfilingPlugin::class)
+                ->setPublic(false)
+                ->setArguments([substr($providerServiceId, strlen('bazinga_geocoder.provider.'))])
+                ->addTag('bazinga_geocoder.profiling_plugin');
+        }
+
+        return array_map(function (string $id) {
+            return new Reference($id);
+        }, $plugins);
     }
 
     /**

DependencyInjection/Compiler/AddProvidersPass.php

@@ -10,6 +10,7 @@
 
 namespace Bazinga\GeocoderBundle\DependencyInjection\Compiler;
 
+use Geocoder\ProviderAggregator;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Reference;
@@ -32,7 +33,7 @@ class AddProvidersPass implements CompilerPassInterface
      */
     public function process(ContainerBuilder $container)
     {
-        if (!$container->hasDefinition('Geocoder\\ProviderAggregator')) {
+        if (!$container->hasDefinition(ProviderAggregator::class)) {
             return;
         }
 
@@ -41,7 +42,7 @@ public function process(ContainerBuilder $container)
             $providers[] = new Reference($providerId);
         }
 
-        $geocoderDefinition = $container->getDefinition('Geocoder\\ProviderAggregator');
+        $geocoderDefinition = $container->getDefinition(ProviderAggregator::class);
         $geocoderDefinition->addMethodCall('registerProviders', [$providers]);
     }
 }

DependencyInjection/Compiler/ProfilerPass.php

@@ -11,7 +11,6 @@
 namespace Bazinga\GeocoderBundle\DependencyInjection\Compiler;
 
 use Bazinga\GeocoderBundle\DataCollector\GeocoderDataCollector;
-use Bazinga\GeocoderBundle\DataCollector\ProfilingProvider;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Reference;
@@ -34,12 +33,7 @@ public function process(ContainerBuilder $container)
 
         $dataCollector = $container->getDefinition(GeocoderDataCollector::class);
 
-        foreach ($container->findTaggedServiceIds('bazinga_geocoder.provider') as $providerId => $attributes) {
-            $container->register($providerId.'.debug', ProfilingProvider::class)
-                ->setDecoratedService($providerId)
-                ->setArguments([
-                    new Reference($providerId.'.debug.inner'),
-                ]);
+        foreach ($container->findTaggedServiceIds('bazinga_geocoder.profiling_plugin') as $providerId => $attributes) {
             $dataCollector->addMethodCall('addInstance', [new Reference($providerId)]);
         }
     }

DependencyInjection/Configuration.php

@@ -95,12 +95,68 @@ private function getProvidersNode()
                     ->variableNode('options')->defaultValue([])->end()
                     ->scalarNode('cache')->defaultNull()->end()
                     ->scalarNode('cache_lifetime')->defaultNull()->end()
+                    ->scalarNode('limit')->defaultNull()->end()
+                    ->scalarNode('locale')->defaultNull()->end()
+                    ->scalarNode('logger')->defaultNull()->end()
                     ->arrayNode('aliases')
                         ->prototype('scalar')->end()
                     ->end()
+                    ->append($this->createClientPluginNode())
                 ->end()
             ->end();
 
         return $node;
     }
+
+    /**
+     * Create plugin node of a client.
+     *
+     * @return ArrayNodeDefinition The plugin node
+     */
+    private function createClientPluginNode()
+    {
+        $builder = new TreeBuilder();
+        $node = $builder->root('plugins');
+
+        /** @var ArrayNodeDefinition $pluginList */
+        $pluginList = $node
+            ->info('A list of plugin service ids. The order is important.')
+            ->prototype('array')
+        ;
+        $pluginList
+            // support having just a service id in the list
+            ->beforeNormalization()
+                ->always(function ($plugin) {
+                    if (is_string($plugin)) {
+                        return [
+                            'reference' => [
+                                'enabled' => true,
+                                'id' => $plugin,
+                            ],
+                        ];
+                    }
+
+                    return $plugin;
+                })
+            ->end()
+        ;
+
+        $pluginList
+            ->children()
+                ->arrayNode('reference')
+                    ->canBeEnabled()
+                    ->info('Reference to a plugin service')
+                    ->children()
+                        ->scalarNode('id')
+                            ->info('Service id of a plugin')
+                            ->isRequired()
+                            ->cannotBeEmpty()
+                        ->end()
+                    ->end()
+                ->end()
+            ->end()
+        ->end();
+
+        return $node;
+    }
 }