Bundles support

Command/BundleAwareTrait.php

@@ -0,0 +1,157 @@
+<?php
+declare(strict_types=1);
+
+namespace AntiMattr\Bundle\MongoDBMigrationsBundle\Command;
+
+use AntiMattr\MongoDB\Migrations\Configuration\Configuration;
+use AntiMattr\MongoDB\Migrations\Configuration\Interfaces\ConfigurationInterface;
+use AntiMattr\MongoDB\Migrations\OutputWriter;
+use Doctrine\MongoDB\Connection;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Symfony\Component\HttpKernel\Bundle\BundleInterface;
+
+/**
+ * Trait BundleAwareTrait
+ * @package AntiMattr\Bundle\MongoDBMigrationsBundle\Command
+ * @author Watari <watari.mailbox@gmail.com>
+ *
+ * @property ContainerInterface $container
+ */
+trait BundleAwareTrait
+{
+
+    protected $configuration;
+
+    /**
+     * @param \Symfony\Component\Console\Input\InputInterface   $input
+     * @param \Symfony\Component\Console\Output\OutputInterface $output
+     *
+     * @return \AntiMattr\MongoDB\Migrations\Configuration\Interfaces\ConfigurationInterface
+     */
+
+    /**
+     * @param \Symfony\Component\Console\Input\InputInterface   $input
+     * @param \Symfony\Component\Console\Output\OutputInterface $output
+     *
+     * @return \AntiMattr\MongoDB\Migrations\Configuration\Interfaces\ConfigurationInterface
+     */
+    protected function getMigrationConfiguration(InputInterface $input, OutputInterface $output): ConfigurationInterface
+    {
+        if (null === $this->configuration) {
+            $configuration = parent::getMigrationConfiguration($input, $output);
+
+            $bundleAlias = $input->getOption('bundle');
+
+            if (Configuration::DEFAULT_PREFIX !== $bundleAlias) {
+                $bundle = CommandHelper::getBundleByAlias($bundleAlias, $this->container);
+                if (null == $bundle) {
+                    throw new \InvalidArgumentException("Bundle is not found for specified alias {$bundleAlias}");
+                } else {
+                    $configuration = $this->getConfigurationBuilder()
+                                          ->setConnection($configuration->getConnection())
+                                          ->setOutputWriter($configuration->getOutputWriter())
+                                          ->build();
+                    CommandHelper::configureConfiguration(
+                        $this->container,
+                        CommandHelper::getConfigParamsForBundle($this->container, $bundle),
+                        $configuration
+                    );
+                }
+            } else {
+                CommandHelper::configureConfiguration(
+                    $this->container,
+                    CommandHelper::getConfigParams($this->container),
+                    $configuration
+                );
+            }
+
+            $this->configuration = $configuration;
+        }
+
+        return  $this->configuration;
+    }
+
+
+    /**
+     * @param InputInterface  $input
+     * @param OutputInterface $output
+     *
+     * @return ConfigurationInterface[]
+     */
+    protected function getMigrationConfigurations(InputInterface $input, OutputInterface $output): array
+    {
+        $configs = [$this->getMigrationConfiguration($input, $output)];
+
+        $includeAllBundles = $input->getOption('include-bundles');
+        $bundleAliasesList = $input->getOption('include-bundle');
+
+        if (!empty($includeAllBundles) && !empty($bundleAliasesList)) {
+            throw new \InvalidArgumentException(
+                'Options "include-bundles" and "include-bundle" cannot be specified simultaneously.'
+            );
+        }
+
+        $outputWriter = new OutputWriter(
+            function ($message) use ($output) {
+                return $output->writeln($message);
+            }
+        );
+        $databaseConnection = $this->getDatabaseConnection($input);
+        $matchedBundles = [];
+
+        if ($includeAllBundles) {
+            /** @var array $registeredBundles */
+            $registeredBundles = $this->container->getParameter('mongo_db_migrations.bundles');
+            /** @var BundleInterface[] $appBundles */
+            $appBundles = $this->container->get('kernel')->getBundles();
+
+            foreach ($appBundles as $bundle) {
+                $bundleExtension = $bundle->getContainerExtension();
+                if (null !== $bundleExtension && !empty($registeredBundles[$bundleExtension->getAlias()])) {
+                    $matchedBundles[] = $bundle;
+                }
+            }
+        } elseif (!empty($bundleAliasesList)) {
+            /** @var array $registeredBundles */
+            $registeredBundles = $this->container->getParameter('mongo_db_migrations.bundles');
+            /** @var BundleInterface[] $appBundles */
+            $appBundles = $this->container->get('kernel')->getBundles();
+            $bundleAliasesMap = \array_flip($bundleAliasesList);
+            foreach ($appBundles as $bundle) {
+                $bundleExtension = $bundle->getContainerExtension();
+                if (
+                    null !== $bundleExtension && !empty($registeredBundles[$bundleExtension->getAlias()])
+                    && isset($bundleAliasesMap[$bundleExtension->getAlias()])
+                ) {
+                    $matchedBundles[] = $bundle;
+                }
+            }
+        }
+
+        foreach ($matchedBundles as $bundle) {
+            $configs[] = $this->createConfiguration(
+                $databaseConnection,
+                $outputWriter,
+                CommandHelper::getConfigParamsForBundle($this->container, $bundle)
+            );
+        }
+
+        return $configs;
+    }
+
+    protected function createConfiguration(
+        Connection $connection,
+        OutputWriter $outputWriter,
+        array $params
+    ): ConfigurationInterface {
+        $configuration = $this->getConfigurationBuilder()
+                              ->setConnection($connection)
+                              ->setOutputWriter($outputWriter)
+                              ->build();
+        CommandHelper::configureConfiguration($this->container, $params, $configuration);
+
+        return $configuration;
+    }
+}

Command/CommandHelper.php

@@ -1,4 +1,5 @@
 <?php
+declare(strict_types=1);
 
 /*
  * This file is part of the AntiMattr MongoDB Migrations Bundle, a library by Matthew Fitzgerald.
@@ -11,11 +12,12 @@
 
 namespace AntiMattr\Bundle\MongoDBMigrationsBundle\Command;
 
-use AntiMattr\MongoDB\Migrations\Configuration\Configuration;
+use AntiMattr\MongoDB\Migrations\Configuration\Interfaces\ConfigurationInterface;
 use Doctrine\ODM\MongoDB\Tools\Console\Helper\DocumentManagerHelper;
 use Symfony\Bundle\FrameworkBundle\Console\Application;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 use Symfony\Component\DependencyInjection\ContainerAwareInterface;
+use Symfony\Component\HttpKernel\Bundle\BundleInterface;
 
 /**
  * @author Matthew Fitzgerald <matthewfitz@gmail.com>
@@ -25,23 +27,32 @@ final class CommandHelper
     /**
      * configureMigrations.
      *
-     * @param ContainerInterface $container
-     * @param Configuration      $configuration
+     * @param ContainerInterface     $container
+     * @param ConfigurationInterface $configuration
      */
-    public static function configureMigrations(ContainerInterface $container, Configuration $configuration)
+    public static function configureMigrations(ContainerInterface $container, ConfigurationInterface $configuration)
     {
-        $dir = $container->getParameter('mongo_db_migrations.dir_name');
-        if (!file_exists($dir)) {
-            mkdir($dir, 0777, true);
+        $params = self::getConfigParams($container);
+        self::configureConfiguration($container, $params, $configuration);
+    }
+
+    public static function configureConfiguration(
+        ContainerInterface $container,
+        array $params,
+        ConfigurationInterface $configuration
+    ): void {
+        if (!\file_exists($params['dir_name'])) {
+            \mkdir($params['dir_name'], 0777, true);
         }
 
-        $configuration->setMigrationsCollectionName($container->getParameter('mongo_db_migrations.collection_name'));
-        $configuration->setMigrationsDatabaseName($container->getParameter('mongo_db_migrations.database_name'));
-        $configuration->setMigrationsDirectory($dir);
-        $configuration->setMigrationsNamespace($container->getParameter('mongo_db_migrations.namespace'));
-        $configuration->setName($container->getParameter('mongo_db_migrations.name'));
-        $configuration->registerMigrationsFromDirectory($dir);
-        $configuration->setMigrationsScriptDirectory($container->getParameter('mongo_db_migrations.script_dir_name'));
+        $configuration->setPrefix($params['prefix']);
+        $configuration->setMigrationsCollectionName($params['collection_name']);
+        $configuration->setMigrationsDatabaseName($params['database_name']);
+        $configuration->setMigrationsDirectory($params['dir_name']);
+        $configuration->setMigrationsNamespace($params['namespace']);
+        $configuration->setName($params['name']);
+        $configuration->registerMigrationsFromDirectory($params['dir_name']);
+        $configuration->setMigrationsScriptDirectory($params['script_dir_name']);
 
         self::injectContainerToMigrations($container, $configuration->getMigrations());
     }
@@ -62,6 +73,63 @@ public static function setApplicationDocumentManager(Application $application, $
         $helperSet->set(new DocumentManagerHelper($dm), 'dm');
     }
 
+    public static function getConfigParams(ContainerInterface $container): array
+    {
+        return [
+            'collection_name' => $container->getParameter('mongo_db_migrations.collection_name'),
+            'database_name' => $container->getParameter('mongo_db_migrations.database_name'),
+            'script_dir_name' => $container->getParameter('mongo_db_migrations.script_dir_name'),
+            'name' => $container->getParameter('mongo_db_migrations.name'),
+            'namespace' => $container->getParameter('mongo_db_migrations.namespace'),
+            'dir_name' => $container->getParameter('mongo_db_migrations.dir_name'),
+            'prefix' => \AntiMattr\MongoDB\Migrations\Configuration\Configuration::DEFAULT_PREFIX,
+        ];
+    }
+
+    public static function getConfigParamsForBundle(
+        ContainerInterface $container,
+        BundleInterface $bundle
+    ): array {
+        if ($bundle->getContainerExtension() == null) {
+            throw new \InvalidArgumentException(
+                "Bundle with name {$bundle->getName()} do not have bundle extension. Bundle alias cannot be defined."
+            );
+        }
+        $bundleAlias = $bundle->getContainerExtension()->getAlias();
+        $bundleConfigs = $container->getParameter('mongo_db_migrations.bundles');
+        if (empty($bundleConfigs[$bundleAlias])) {
+            throw new \RuntimeException("Bundle with alias {$bundleAlias} has no registered migration configs");
+        }
+
+        $bundleConfig = $bundleConfigs[$bundleAlias];
+
+        return [
+            'collection_name' => $container->getParameter('mongo_db_migrations.collection_name'),
+            'database_name' => $container->getParameter('mongo_db_migrations.database_name'),
+            'script_dir_name' => $container->getParameter('mongo_db_migrations.script_dir_name'),
+            'namespace' => $bundle->getNamespace() . '\\' . $bundleConfig['namespace'],
+            'dir_name' => $bundle->getPath() . '/' . $bundleConfig['dir_name'],
+            'name' => $bundleConfig['name'],
+            'prefix' => $bundleAlias,
+        ];
+    }
+
+    public static function getBundleByAlias(string $bundleAlias, ContainerInterface $container): ?BundleInterface
+    {
+        /** @var BundleInterface[] $bundles */
+        $bundles = $container->get('kernel')->getBundles();
+        $targetBundle = null;
+        foreach ($bundles as $bundle) {
+            $containerExtension = $bundle->getContainerExtension();
+            if (null !== $containerExtension && $containerExtension->getAlias() === $bundleAlias) {
+                $targetBundle = $bundle;
+                break;
+            }
+        }
+
+        return $targetBundle;
+    }
+
     /**
      * injectContainerToMigrations.
      *

Command/MigrationsBCFixCommand.php

@@ -0,0 +1,62 @@
+<?php
+declare(strict_types = 1);
+
+/*
+ * This file is part of the AntiMattr MongoDB Migrations Bundle, a library by Matthew Fitzgerald.
+ *
+ * (c) 2014 Matthew Fitzgerald
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace AntiMattr\Bundle\MongoDBMigrationsBundle\Command;
+
+use AntiMattr\MongoDB\Migrations\Tools\Console\Command\BCFixCommand;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
+use Symfony\Component\Console\Output\OutputInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * @author Watari <watari.mailbox@gmail.com>
+ */
+class MigrationsBCFixCommand extends BCFixCommand
+{
+
+    protected $container;
+
+    public function __construct(?string $name = null, ContainerInterface $container)
+    {
+        parent::__construct($name);
+        $this->container = $container;
+    }
+
+
+    protected function configure(): void
+    {
+        parent::configure();
+
+        $this->setName('mongodb:migrations:bc-fix');
+        $this->addOption(
+            'dm',
+            null,
+            InputOption::VALUE_OPTIONAL,
+            'The document manager to use for this command.',
+            'default_document_manager'
+        );
+    }
+
+    public function execute(InputInterface $input, OutputInterface $output): void
+    {
+        CommandHelper::setApplicationDocumentManager($this->getApplication(), $input->getOption('dm'));
+        $configuration = $this->getMigrationConfiguration($input, $output);
+        CommandHelper::configureConfiguration(
+            $this->container,
+            CommandHelper::getConfigParams($this->container),
+            $configuration
+        );
+
+        parent::execute($input, $output);
+    }
+}