Merge branch 'feature/factory-creation' into release-1.0.0

Close #52
Fixes #42

CHANGELOG.md

@@ -6,11 +6,27 @@ All notable changes to this project will be documented in this file, in reverse
 
 ### Added
 
-- Nothing.
+- [#52](https://github.com/zendframework/zend-expressive-tooling/pull/52) adds
+  the command `factory:create`. The command expects a fully-qualified,
+  resolvable, class name; it then generates a factory class for it as a sibling
+  class file, using reflection. By default, it also registers the class and
+  factory with the container, in the file `config/autoload/zend-expressive-tooling-factories.global.php`.
+  Pass the option `--no-register` to disable this auto-registration.
 
 ### Changed
 
-- Nothing.
+- [#52](https://github.com/zendframework/zend-expressive-tooling/pull/52)
+  modifies the `middleware:create` command to invoke `factory:create` once it
+  has successfully created the new middleware. You may disable this feature by
+  passing the option `--no-factory`; if you want to generate the factory, but
+  not auto-register the middleware service, pass the option `--no-register`.
+
+- [#52](https://github.com/zendframework/zend-expressive-tooling/pull/52)
+  modifies the `handler:create` command to invoke `factory:create` once it has
+  successfully created the new request handler. You may disable this feature by
+  passing the option `--no-factory`; if you want to generate the factory, but
+  not auto-register the request handler service, pass the option
+  `--no-register`.
 
 ### Deprecated
 

bin/expressive

@@ -30,6 +30,7 @@ if (file_exists($a = __DIR__ . '/../../../autoload.php')) {
 
 $application = new Application('expressive', VERSION);
 $application->addCommands([
+    new Factory\CreateFactoryCommand('factory:create'),
     new CreateHandler\CreateHandlerCommand('handler:create'),
     new CreateMiddleware\CreateMiddlewareCommand('middleware:create'),
     new MigrateInteropMiddleware\MigrateInteropMiddlewareCommand('migrate:interop-middleware'),

src/CreateHandler/CreateHandlerCommand.php

@@ -10,7 +10,9 @@
 namespace Zend\Expressive\Tooling\CreateHandler;
 
 use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\ArrayInput;
 use Symfony\Component\Console\Input\InputArgument;
+use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Output\OutputInterface;
 
@@ -30,6 +32,28 @@ class. For a path, it matches the class namespace against PSR-4 autoloader
 escape sequences by your shell.
 EOT;
 
+    const HELP_OPT_NO_FACTORY = <<< 'EOT'
+By default, this command generates a factory for the request handler it
+creates, and registers it with the container. Passing this option disables
+that feature.
+EOT;
+
+    const HELP_OPT_NO_REGISTER = <<< 'EOT'
+By default, when this command generates a factory for the request handler it
+creates, it registers it with the container. Passing this option disables
+registration of the generated factory with the container.
+EOT;
+
+    /**
+     * Flag indicating whether or not to require the generated handler before
+     * generating its factory. By default, this is true, as it is necessary
+     * in order for the handler to be reflected. However, during testing, we do
+     * not actually generate a handler, so we need a way to disable it.
+     *
+     * @var bool
+     */
+    private $requireHandlerBeforeGeneratingFactory = true;
+
     /**
      * Configure the console command.
      */
@@ -38,6 +62,8 @@ protected function configure()
         $this->setDescription('Create a PSR-15 request handler class file.');
         $this->setHelp(self::HELP);
         $this->addArgument('handler', InputArgument::REQUIRED, self::HELP_ARG_HANDLER);
+        $this->addOption('no-factory', null, InputOption::VALUE_NONE, self::HELP_OPT_NO_FACTORY);
+        $this->addOption('no-register', null, InputOption::VALUE_NONE, self::HELP_OPT_NO_REGISTER);
     }
 
     /**
@@ -63,6 +89,24 @@ protected function execute(InputInterface $input, OutputInterface $output)
             $path
         ));
 
+        if (! $input->getOption('no-factory')) {
+            if ($this->requireHandlerBeforeGeneratingFactory) {
+                require $path;
+            }
+            return $this->generateFactory($handler, $input, $output);
+        }
+
         return 0;
     }
+
+    private function generateFactory(string $handlerClass, InputInterface $input, OutputInterface $output) : int
+    {
+        $factoryInput = new ArrayInput([
+            'command'       => 'factory:create',
+            'class'         => $handlerClass,
+            '--no-register' => $input->getOption('no-register'),
+        ]);
+        $command = $this->getApplication()->find('factory:create');
+        return $command->run($factoryInput, $output);
+    }
 }

src/CreateMiddleware/CreateMiddlewareCommand.php

@@ -10,8 +10,10 @@
 namespace Zend\Expressive\Tooling\CreateMiddleware;
 
 use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\ArrayInput;
 use Symfony\Component\Console\Input\InputArgument;
 use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Input\InputOption;
 use Symfony\Component\Console\Output\OutputInterface;
 
 class CreateMiddlewareCommand extends Command
@@ -30,6 +32,27 @@ class CreateMiddlewareCommand extends Command
 escape sequences by your shell.
 EOT;
 
+    const HELP_OPT_NO_FACTORY = <<< 'EOT'
+By default, this command generates a factory for the middleware it creates, and
+registers it with the container. Passing this option disables that feature.
+EOT;
+
+    const HELP_OPT_NO_REGISTER = <<< 'EOT'
+By default, when this command generates a factory for the middleware it
+creates, it registers it with the container. Passing this option disables
+registration of the generated factory with the container.
+EOT;
+
+    /**
+     * Flag indicating whether or not to require the generated middleware before
+     * generating its factory. By default, this is true, as it is necessary
+     * in order for the middleware to be reflected. However, during testing, we do
+     * not actually generate a middleware, so we need a way to disable it.
+     *
+     * @var bool
+     */
+    private $requireMiddlewareBeforeGeneratingFactory = true;
+
     /**
      * Configure the console command.
      */
@@ -38,6 +61,8 @@ protected function configure()
         $this->setDescription('Create a PSR-15 middleware class file.');
         $this->setHelp(self::HELP);
         $this->addArgument('middleware', InputArgument::REQUIRED, self::HELP_ARG_MIDDLEWARE);
+        $this->addOption('no-factory', null, InputOption::VALUE_NONE, self::HELP_OPT_NO_FACTORY);
+        $this->addOption('no-register', null, InputOption::VALUE_NONE, self::HELP_OPT_NO_REGISTER);
     }
 
     /**
@@ -63,6 +88,24 @@ protected function execute(InputInterface $input, OutputInterface $output)
             $path
         ));
 
+        if (! $input->getOption('no-factory')) {
+            if ($this->requireMiddlewareBeforeGeneratingFactory) {
+                require $path;
+            }
+            return $this->generateFactory($middleware, $input, $output);
+        }
+
         return 0;
     }
+
+    private function generateFactory(string $middlewareClass, InputInterface $input, OutputInterface $output) : int
+    {
+        $factoryInput = new ArrayInput([
+            'command'       => 'factory:create',
+            'class'         => $middlewareClass,
+            '--no-register' => $input->getOption('no-register'),
+        ]);
+        $command = $this->getApplication()->find('factory:create');
+        return $command->run($factoryInput, $output);
+    }
 }

src/Factory/ClassNotFoundException.php

@@ -0,0 +1,23 @@
+<?php
+/**
+ * @see       https://github.com/zendframework/zend-expressive-tooling for the canonical source repository
+ * @copyright Copyright (c) 2018 Zend Technologies USA Inc. (https://www.zend.com)
+ * @license   https://github.com/zendframework/zend-expressive-tooling/blob/master/LICENSE.md New BSD License
+ */
+
+declare(strict_types=1);
+
+namespace Zend\Expressive\Tooling\Factory;
+
+use InvalidArgumentException;
+
+class ClassNotFoundException extends InvalidArgumentException
+{
+    public static function forClassName(string $className) : self
+    {
+        return new self(sprintf(
+            'Class "%s" could not be autoloaded; did you perhaps mis-type it?',
+            $className
+        ));
+    }
+}

src/Factory/ConfigFileNotWritableException.php

@@ -0,0 +1,24 @@
+<?php
+/**
+ * @see       https://github.com/zendframework/zend-expressive-tooling for the canonical source repository
+ * @copyright Copyright (c) 2018 Zend Technologies USA Inc. (https://www.zend.com)
+ * @license   https://github.com/zendframework/zend-expressive-tooling/blob/master/LICENSE.md New BSD License
+ */
+
+declare(strict_types=1);
+
+namespace Zend\Expressive\Tooling\Factory;
+
+use RuntimeException;
+
+class ConfigFileNotWritableException extends RuntimeException
+{
+    public static function forFile(string $file) : self
+    {
+        return new self(sprintf(
+            'Cannot write factory configuration to file "%s";'
+            . ' please make sure the file and directory are writable',
+            $file
+        ));
+    }
+}

src/Factory/ConfigInjector.php

@@ -0,0 +1,94 @@
+<?php
+/**
+ * @see       https://github.com/zendframework/zend-expressive-tooling for the canonical source repository
+ * @copyright Copyright (c) 2018 Zend Technologies USA Inc. (https://www.zend.com)
+ * @license   https://github.com/zendframework/zend-expressive-tooling/blob/master/LICENSE.md New BSD License
+ */
+
+declare(strict_types=1);
+
+namespace Zend\Expressive\Tooling\Factory;
+
+use const SORT_NATURAL;
+
+/**
+ * Inject factory configuration in an autoloadable location.
+ *
+ * This class will re-generate the file denoted by its CONFIG_FILE constant.
+ * It first pulls in the data in that file, if the file exists, and then adds
+ * an entry for the given class, pointing it to the given factory, rewriting
+ * the configuration file on completion.
+ */
+class ConfigInjector
+{
+    public const CONFIG_FILE = 'config/autoload/zend-expressive-tooling-factories.global.php';
+
+    public const TEMPLATE = <<<'EOT'
+<?php
+/**
+ * This file generated by %1$s.
+ *
+ * Modifications should be kept at a minimum, and restricted to adding or
+ * removing factory definitions; other dependency types may be overwritten
+ * when regenerating this file via zend-expressive-tooling commands.
+ */
+
+return [
+    'dependencies' => [
+        'factories' => [
+%2$s,
+        ],
+    ],
+];
+EOT;
+
+    /**
+     * @var string
+     */
+    private $configFile;
+
+    public function __construct(string $projectRoot = '')
+    {
+        $this->configFile = $projectRoot === ''
+            ? self::CONFIG_FILE
+            : sprintf('%s/%s', rtrim($projectRoot, '/'), self::CONFIG_FILE);
+    }
+
+    public function injectFactoryForClass(string $factory, string $class) : string
+    {
+        if (! $this->configIsWritable()) {
+            throw ConfigFileNotWritableException::forFile($this->configFile);
+        }
+
+        $config = file_exists($this->configFile) ? include $this->configFile : [];
+        $config = $config['dependencies']['factories'] ?? [];
+        $config[$class] = $factory;
+        $configContents = sprintf(
+            self::TEMPLATE,
+            __CLASS__,
+            $this->normalizeConfig($config)
+        );
+        file_put_contents($this->configFile, $configContents);
+
+        return $this->configFile;
+    }
+
+    private function configIsWritable() : bool
+    {
+        return is_writable($this->configFile)
+            || (! file_exists($this->configFile) && is_writable(dirname($this->configFile)));
+    }
+
+    private function normalizeConfig(array $config) : string
+    {
+        $normalized = [];
+        ksort($config, SORT_NATURAL);
+        foreach ($config as $class => $factory) {
+            $class .= '::class';
+            $factory .= '::class';
+
+            $normalized[] = sprintf('%s%s => %s', str_repeat(' ', 12), $class, $factory);
+        }
+        return implode(",\n", $normalized);
+    }
+}