visto9259/zf-console-symfony

This package is abandoned and no longer maintained. The author suggests using the visto9259/laminas-console-symfony package instead.

A Zend Framework Console application based on Symfony Console

1.0.0 2020-07-10 14:34 UTC

Requires

• symfony/console: ^5.0
• zendframework/zend-config-aggregator: ~1.0
• zendframework/zend-loader: ~2.6
• zendframework/zend-modulemanager: ~2.8.0
• zendframework/zend-servicemanager: ^3.0.0

MIT

• Eric Richer

README

This pacakged is deprecated and no longer supported

Use laminas-console-symfony instead.

Zf-Console-Symfony: A ZF3 console app using Symfony Console

Introduction

zf-console-symfony provides a replacement for zf-console with a wrapper for the symfony/console component.

For developers familiar with ZF3 MVC application, this package is inspired by zend-mvc in its usage of modules and dependency injection using the Service Manager.

Requirements

Please see the composer.json file.

Installation

Run the following composer command:

$ composer require visto9259/zf-console-symfony

Or, alternatively, manually add the following to your composer.json, in the require section:

"require" : {
    "visto9259/zf-console-symfony" : "^1.0.0"
}

And then run composer update to ensure the module is installed.

Creating a console application

The console application skeleton is based on the Zend Framework MVC Application skeleton. It follows a similar directory structure:

MyApp/
   config/
      autoload/
         global.php
         local.php
         ... other config files
      application.config.php
      modules.config.php
      commands.config.php
      development.config.php (optional)
   module/
      myModule/
        config/
           module.config.php (optional)
        src/
           Module.php
   vendor/
      composer/
      ...
      autoload.php (created by Composer)
   myapp.php (entry point of the application)

The myapp.php file contains the console application code and can be as simple as:

require __DIR__.'/vendor/autoload.php';
     
use Zend\Stdlib\ArrayUtils;
use ZFSymfonyConsole\Application;
     
// Setup the application
$appConfig = require __DIR__ . '/config/application.config.php_dist';
if (file_exists(__DIR__ . '/config/development.config.php')) {
   $appConfig = ArrayUtils::merge($appConfig, require __DIR__ . '/config/development.config.php');
}
$application = new Application($appConfig);
     
$exit = $application->run();

Configuring the application

The file application_config.php provides the configuration for the console application and for the loading of the modules using the Zend Framework Module Manager. It contains the following:

return [
    'console_application_options' => [
        'name' => 'Test',
        'version' => '0.1',
    ],
    'commands' => require __DIR__ . '/commands.config.php_dist',
    'modules' => require __DIR__ . '/modules.config.php',
    'module_listener_options' => [
        'module_paths' => [
            './module',
            './vendor',
        ],
        'config_glob_paths' => [
            realpath(__DIR__) . '/autoload/{{,*.}global,{,*.}local}.php',
        ],
    ],
    'service_manager' => [
        // typical Service Manager configation
    ],   
];

console_application_options contains the $name and $version arguments passed to Symfony\Component\Console\Application constructor.

commands is an array of command configurations. See Defining Commands for details.

modules and module_listener_options are the Module Manager configuration parameters.

service_manager contains the typical ZendFramework Service Manager configuration which allows for services, factories and so on to be defined.

Differences with zend-mvc applications

This application is inspired by the zend-mvc application but it is not intended to implement a full-fledge MVC application. It is a wrapper around the Symfony Console Application that provides a Service Manager for dependency injection and uses the Module Manager to load modules.

The intent is that if one wants to use an existing or a custom ZendFramework module, it can be added to the list of modules to be loaded. For example, if a module defines services to access a database, it will be loaded by the Module Manager and its services added to the Service Manager.

Limitations in Module Configuration

The ZFConsoleSymfony application uses the Module Manager loadModules() method to load modules but will only service modules that implement the ServiceProviderInterface and the ConfigProviderInterfaceinterfaces. All other provider interfaces are ignored.

Important: The Module class SHOULD NOT implement the BootstrapListenerInterface and InitProviderInterface for the time being. These will make the application crash.

Defining commands

Symfony Console commands can be defined in the config/commands.config.php. They will be instantiated and added to Console application when it is created.

A typical commands.config.php would contain the following:

use Symfony\Component\Console\Input\InputArgument;
use Symfony\Component\Console\Input\InputOption;
use ZFSymfonyConsole\Factory\AbstractCommandFactory;

return [
    'commands' => [
        [
            'name' => 'test',
            'description' => 'Test command',
            'help' => 'Test help message',
            'class' => Test::class,
            'arguments' => [
                [
                    'name' => 'arg1',
                    'mode' => InputArgument::OPTIONAL,
                    'description' => 'Argument 1',
                ],
                [
                    'name' => 'arg2',
                    'mode' => InputArgument::OPTIONAL,
                    'description' => 'Argument 2',
                    'default' => 'some default',
                ],
            ],
            'options' => [
                [
                    'name' => 'yell',
                    'shortcut' => 'y',
                    'mode' => InputOption::VALUE_REQUIRED,
                    'description' => 'yell option',
                ],
            ],
        ],
    ],
    'service_manager' => [
        'factories' => [
            Test::class => AbstractCommandFactory::class,
        ]
    ]
];

commands is an array of Symfony Command definitions. The name, description and help usage is defined in the Symfony Command documentation. Thearguments and options arrays contains lists of Symfony InputArgumentand InputOptions definitions.

The class element of a command definition refers to the name of the class that implements the Symfony Command. It is mandatory that the class extends the Symfony\Component\Console\Command\Command class. classcan either by a class name or a string. The application will use the ZendFramework Service Manager to instantiate the class which allows for the use of factories to create the command and inject dependencies. class can also be an instance of a Symfony\Component\Console\Command\Command class.

service_manager contains the typical Service Manager configuration that will be added to the application Service Manager.
If a Command does not need a specific factory to create it, the class element of the Command definition can simply provide the class name of the Command and the Service Manager will use AbstractCommandFactory to create the command.

Feedback

This package is work-in-progress. It has not been thoroughly tested for all thinkable cases. If you find a problem, please log an issue.

I am also very opened to feedback and suggestions for improvements.

© 2019 Eric Richer ([e-mail])