www.aleph1.co.uk Git - yaffs-website/blob - vendor/behat/behat/src/Behat/Behat/Definition/ServiceContainer/DefinitionExtension.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Behat.
   5  * (c) Konstantin Kudryashov <ever.zet@gmail.com>
   6  *
   7  * For the full copyright and license information, please view the LICENSE
   8  * file that was distributed with this source code.
   9  */
  10
  11 namespace Behat\Behat\Definition\ServiceContainer;
  12
  13 use Behat\Behat\Context\ServiceContainer\ContextExtension;
  14 use Behat\Testwork\Argument\ServiceContainer\ArgumentExtension;
  15 use Behat\Behat\Gherkin\ServiceContainer\GherkinExtension;
  16 use Behat\Testwork\Cli\ServiceContainer\CliExtension;
  17 use Behat\Testwork\Environment\ServiceContainer\EnvironmentExtension;
  18 use Behat\Testwork\ServiceContainer\Extension;
  19 use Behat\Testwork\ServiceContainer\ExtensionManager;
  20 use Behat\Testwork\ServiceContainer\ServiceProcessor;
  21 use Behat\Testwork\Suite\ServiceContainer\SuiteExtension;
  22 use Behat\Testwork\Translator\ServiceContainer\TranslatorExtension;
  23 use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
  24 use Symfony\Component\DependencyInjection\ContainerBuilder;
  25 use Symfony\Component\DependencyInjection\Definition;
  26 use Symfony\Component\DependencyInjection\Reference;
  27
  28 /**
  29  * Extends Behat with definition services.
  30  *
  31  * @author Konstantin Kudryashov <ever.zet@gmail.com>
  32  */
  33 final class DefinitionExtension implements Extension
  34 {
  35     /*
  36      * Available services
  37      */
  38     const FINDER_ID = 'definition.finder';
  39     const REPOSITORY_ID = 'definition.repository';
  40     const PATTERN_TRANSFORMER_ID = 'definition.pattern_transformer';
  41     const WRITER_ID = 'definition.writer';
  42     const DEFINITION_TRANSLATOR_ID = 'definition.translator';
  43
  44     /*
  45      * Available extension points
  46      */
  47     const SEARCH_ENGINE_TAG = 'definition.search_engine';
  48     const PATTERN_POLICY_TAG = 'definition.pattern_policy';
  49
  50     /**
  51      * @var ServiceProcessor
  52      */
  53     private $processor;
  54
  55     /**
  56      * Initializes compiler pass.
  57      *
  58      * @param null|ServiceProcessor $processor
  59      */
  60     public function __construct(ServiceProcessor $processor = null)
  61     {
  62         $this->processor = $processor ? : new ServiceProcessor();
  63     }
  64
  65     /**
  66      * {@inheritdoc}
  67      */
  68     public function getConfigKey()
  69     {
  70         return 'definitions';
  71     }
  72
  73     /**
  74      * {@inheritdoc}
  75      */
  76     public function initialize(ExtensionManager $extensionManager)
  77     {
  78     }
  79
  80     /**
  81      * {@inheritdoc}
  82      */
  83     public function configure(ArrayNodeDefinition $builder)
  84     {
  85     }
  86
  87     /**
  88      * {@inheritdoc}
  89      */
  90     public function load(ContainerBuilder $container, array $config)
  91     {
  92         $this->loadFinder($container);
  93         $this->loadRepository($container);
  94         $this->loadWriter($container);
  95         $this->loadPatternTransformer($container);
  96         $this->loadDefinitionTranslator($container);
  97         $this->loadDefaultSearchEngines($container);
  98         $this->loadDefaultPatternPolicies($container);
  99         $this->loadAnnotationReader($container);
 100         $this->loadDefinitionPrinters($container);
 101         $this->loadController($container);
 102     }
 103
 104     /**
 105      * {@inheritdoc}
 106      */
 107     public function process(ContainerBuilder $container)
 108     {
 109         $this->processSearchEngines($container);
 110         $this->processPatternPolicies($container);
 111     }
 112
 113     /**
 114      * Loads definition finder.
 115      *
 116      * @param ContainerBuilder $container
 117      */
 118     private function loadFinder(ContainerBuilder $container)
 119     {
 120         $definition = new Definition('Behat\Behat\Definition\DefinitionFinder');
 121         $container->setDefinition(self::FINDER_ID, $definition);
 122     }
 123
 124     /**
 125      * Loads definition repository.
 126      *
 127      * @param ContainerBuilder $container
 128      */
 129     private function loadRepository(ContainerBuilder $container)
 130     {
 131         $definition = new Definition('Behat\Behat\Definition\DefinitionRepository', array(
 132             new Reference(EnvironmentExtension::MANAGER_ID)
 133         ));
 134         $container->setDefinition(self::REPOSITORY_ID, $definition);
 135     }
 136
 137     /**
 138      * Loads definition writer.
 139      *
 140      * @param ContainerBuilder $container
 141      */
 142     private function loadWriter(ContainerBuilder $container)
 143     {
 144         $definition = new Definition('Behat\Behat\Definition\DefinitionWriter', array(
 145             new Reference(EnvironmentExtension::MANAGER_ID),
 146             new Reference(self::REPOSITORY_ID)
 147         ));
 148         $container->setDefinition(self::WRITER_ID, $definition);
 149     }
 150
 151     /**
 152      * Loads definition pattern transformer.
 153      *
 154      * @param ContainerBuilder $container
 155      */
 156     private function loadPatternTransformer(ContainerBuilder $container)
 157     {
 158         $definition = new Definition('Behat\Behat\Definition\Pattern\PatternTransformer');
 159         $container->setDefinition(self::PATTERN_TRANSFORMER_ID, $definition);
 160     }
 161
 162     /**
 163      * Loads definition translator.
 164      *
 165      * @param ContainerBuilder $container
 166      */
 167     private function loadDefinitionTranslator(ContainerBuilder $container)
 168     {
 169         $definition = new Definition('Behat\Behat\Definition\Translator\DefinitionTranslator', array(
 170             new Reference(TranslatorExtension::TRANSLATOR_ID)
 171         ));
 172         $container->setDefinition(self::DEFINITION_TRANSLATOR_ID, $definition);
 173     }
 174
 175     /**
 176      * Loads default search engines.
 177      *
 178      * @param ContainerBuilder $container
 179      */
 180     private function loadDefaultSearchEngines(ContainerBuilder $container)
 181     {
 182         $definition = new Definition('Behat\Behat\Definition\Search\RepositorySearchEngine', array(
 183             new Reference(self::REPOSITORY_ID),
 184             new Reference(self::PATTERN_TRANSFORMER_ID),
 185             new Reference(self::DEFINITION_TRANSLATOR_ID),
 186             new Reference(ArgumentExtension::PREG_MATCH_ARGUMENT_ORGANISER_ID)
 187         ));
 188         $definition->addTag(self::SEARCH_ENGINE_TAG, array('priority' => 50));
 189         $container->setDefinition(self::SEARCH_ENGINE_TAG . '.repository', $definition);
 190     }
 191
 192     /**
 193      * Loads default pattern policies.
 194      *
 195      * @param ContainerBuilder $container
 196      */
 197     private function loadDefaultPatternPolicies(ContainerBuilder $container)
 198     {
 199         $definition = new Definition('Behat\Behat\Definition\Pattern\Policy\TurnipPatternPolicy');
 200         $definition->addTag(self::PATTERN_POLICY_TAG, array('priority' => 50));
 201         $container->setDefinition(self::PATTERN_POLICY_TAG . '.turnip', $definition);
 202
 203         $definition = new Definition('Behat\Behat\Definition\Pattern\Policy\RegexPatternPolicy');
 204         $definition->addTag(self::PATTERN_POLICY_TAG, array('priority' => 60));
 205         $container->setDefinition(self::PATTERN_POLICY_TAG . '.regex', $definition);
 206     }
 207
 208     /**
 209      * Loads definition annotation reader.
 210      *
 211      * @param ContainerBuilder $container
 212      */
 213     private function loadAnnotationReader(ContainerBuilder $container)
 214     {
 215         $definition = new Definition('Behat\Behat\Definition\Context\Annotation\DefinitionAnnotationReader');
 216         $definition->addTag(ContextExtension::ANNOTATION_READER_TAG, array('priority' => 50));
 217         $container->setDefinition(ContextExtension::ANNOTATION_READER_TAG . '.definition', $definition);
 218     }
 219
 220     /**
 221      * Loads definition printers.
 222      *
 223      * @param ContainerBuilder $container
 224      */
 225     private function loadDefinitionPrinters(ContainerBuilder $container)
 226     {
 227         $definition = new Definition('Behat\Behat\Definition\Printer\ConsoleDefinitionInformationPrinter', array(
 228             new Reference(CliExtension::OUTPUT_ID),
 229             new Reference(self::PATTERN_TRANSFORMER_ID),
 230             new Reference(self::DEFINITION_TRANSLATOR_ID),
 231             new Reference(GherkinExtension::KEYWORDS_ID)
 232         ));
 233         $container->setDefinition($this->getInformationPrinterId(), $definition);
 234
 235         $definition = new Definition('Behat\Behat\Definition\Printer\ConsoleDefinitionListPrinter', array(
 236             new Reference(CliExtension::OUTPUT_ID),
 237             new Reference(self::PATTERN_TRANSFORMER_ID),
 238             new Reference(self::DEFINITION_TRANSLATOR_ID),
 239             new Reference(GherkinExtension::KEYWORDS_ID)
 240         ));
 241         $container->setDefinition($this->getListPrinterId(), $definition);
 242     }
 243
 244     /**
 245      * Loads definition controller.
 246      *
 247      * @param ContainerBuilder $container
 248      */
 249     private function loadController(ContainerBuilder $container)
 250     {
 251         $definition = new Definition('Behat\Behat\Definition\Cli\AvailableDefinitionsController', array(
 252             new Reference(SuiteExtension::REGISTRY_ID),
 253             new Reference(self::WRITER_ID),
 254             new Reference($this->getListPrinterId()),
 255             new Reference($this->getInformationPrinterId())
 256         ));
 257         $definition->addTag(CliExtension::CONTROLLER_TAG, array('priority' => 500));
 258         $container->setDefinition(CliExtension::CONTROLLER_TAG . '.available_definitions', $definition);
 259     }
 260
 261     /**
 262      * Processes all search engines in the container.
 263      *
 264      * @param ContainerBuilder $container
 265      */
 266     private function processSearchEngines(ContainerBuilder $container)
 267     {
 268         $references = $this->processor->findAndSortTaggedServices($container, self::SEARCH_ENGINE_TAG);
 269         $definition = $container->getDefinition(self::FINDER_ID);
 270
 271         foreach ($references as $reference) {
 272             $definition->addMethodCall('registerSearchEngine', array($reference));
 273         }
 274     }
 275
 276     /**
 277      * Processes all pattern policies.
 278      *
 279      * @param ContainerBuilder $container
 280      */
 281     private function processPatternPolicies(ContainerBuilder $container)
 282     {
 283         $references = $this->processor->findAndSortTaggedServices($container, self::PATTERN_POLICY_TAG);
 284         $definition = $container->getDefinition(self::PATTERN_TRANSFORMER_ID);
 285
 286         foreach ($references as $reference) {
 287             $definition->addMethodCall('registerPatternPolicy', array($reference));
 288         }
 289     }
 290
 291     /**
 292      * returns list printer service id.
 293      *
 294      * @return string
 295      */
 296     private function getListPrinterId()
 297     {
 298         return 'definition.list_printer';
 299     }
 300
 301     /**
 302      * Returns information printer service id.
 303      *
 304      * @return string
 305      */
 306     private function getInformationPrinterId()
 307     {
 308         return 'definition.information_printer';
 309     }
 310 }