Apache Zeta Components - high quality PHP components

• Tutorial
• API

eZ Components - ConsoleTools

Introduction

The ConsoleTools component provides several useful tools to build applications that run on a computer console (sometimes also called shell or command line). For example, eZ Publish includes several shell scripts that perform tasks like clearing caches.

Class overview

The ConsoleTools component offers several (mostly independent) classes to perform different tasks. The main classes are:

ezcConsoleOutput

ezcConsoleOutput is responsible for printing text to the console. It allows you to print text in different colors with different background colors. It can also apply other styling information to the text, making it bold or underlined for example. It can automatically wrap text after a certain number of characters are printed (keeping words intact) and handle output of different verbosity levels. ATTENTION: Windows does not support the styling of text.

ezcConsoleInput

Using this little tool, you can handle the options and arguments provided to your shell application. It is capable of handling and validating three types of option datatypes (string, int and none) and can handle optional and mandatory options as well as rules to define relations between them. Rules can include dependencies and exclusions between options.

ezcConsoleProgressbar

Most often you will use a console application in favor of a web application when it comes to processing time-consuming tasks. To indicate the current progress of a task, a kind of "status indicator" will be used, which is most commonly a progress bar. ezcConsoleProgressbar gives you an easy-to-use interface to display this. It will keep track of re-drawing the bar as needed, showing current and maximum values, as well as percentage completion. It is fully configurable regarding its visual appearance.

ezcConsoleStatusbar

ezcConsoleStatusbar is the "little brother" of ezcConsoleProgressbar. It also allows you to display the progress of a time-consuming action, but does not use a fixed bar-like appearance. Instead, it indicates successful and failed operations by displaying specific characters and keeps a count of successes and failures. This allows you to indicate the progress of a process where you don't initially know the number of actions to be performed.

ezcConsoleProgressMonitor

Sometimes you need to display the progress of several actions and don't want to use a progress bar to do so. In this case you need the status indicator. It allows you to display a status entry for each action and generates the percentage completion of the current step.

ezcConsoleTable

This class lets you easily create tables to be displayed on the console. It has a very convenient interface to create a table and manage the data it contains. It is highly configurable regarding the table's appearance (for example, different color and style information for content and borders on a per-cell basis, character selection for borders, variable width of the table and so on). ezcConsoleTable will also take care of measuring the best width for table columns (to make your content fit best), automatically wrapping content and aligning the content in the cells as indicated.

ezcConsoleDialog

This interface provides a common API for user interaction elements. A console dialog can request information from a user and react on this information interactively. For you as a user of ezcConsoleDialog, a dialog is displayed to the user and returns a result value to you, which was provided by the user of your application in some way. Currently 2 implementations of ezcConsoleDialog exist: ezcConsoleQuestionDialog is a dialog for asking a simply question and retrieving the answer from the user of an application. Instances of the ezcConsoleMenuDialog class display a menu to the user and retrieves his choice of a menu item.

Usage

Printing text to the console

As mentioned, the class ezcConsoleOutput is used to print text to the console. Let's look at a basic example:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $output->formats->info->color = 'blue';
9. $output->outputText( 'Test text in color blue', 'info' );
11. ?>

The ezcConsoleOutput object is simply instantiated. You can optionally submit options and predefined formatting options to its constructor, but this can also be done later.

In line 7, you can see how format is defined. Formats are created on the fly, as soon as you access them (for reading or writing) through the $output->formats attribute. There, we create a format called "info" and assign the color value "blue" to it. This will make all text printed with this format blue. In line 9, you can see how the format is applied to some text at printing time.

The second example shows some more advanced code:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $output->formats->info->color = 'blue';
9. $output->formats->error->color = 'red';
10. $output->formats->error->style = array( 'bold' );
12. $output->formats->fatal->color = 'red';
13. $output->formats->fatal->style = array( 'bold', 'underlined' );
14. $output->formats->fatal->bgcolor = 'black';
16. $output->outputText( 'This is some standard text ' );
17. $output->outputText( 'including some error', 'error' );
18. $output->outputText( ' wrapped in standard text.' );
19. $output->outputText( "\n" );
21. $output->outputLine( 'This is a fatal error message.', 'fatal' );
23. $output->outputText( 'Test' );
25. ?>

In this example, two more formats are defined: "error" and "fatal". These formats have an additional style attribute set, which makes them both appear bold. The "fatal" format will also underline the text and give it a black background color.

The difference between ezcConsoleOutput->outputText() and ezcConsoleOutput->outputLine() is that the latter automatically adds a newline value to your text. The newline sequence used here is adjusted based on the operating system. The use of ezcConsoleOutput->outputLine() is recommended over the direct output of, for example, "n".

If you leave the second parameter of ezcConsoleOutput::outputText() and ezcConsoleOutput::outputLine() out, the "default" format is used. The default is set to your console's default setting, but you can also change this as for any other format you define. A third variant to format text is ezcConsoleOutput->formatText(), which returns the formatted string instead of printing it.

This example shows some of the options ezcConsoleOutput supports:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $output->formats->info->color = 'blue';
8. $output->formats->info->style = array( 'bold' );
10. $output->setOptions( 
11.     array( 
12.         'autobreak'      => 78,
13.         'verbosityLevel' => 3
14.     )
15. );
17. $output->outputLine( 'This is a very very long info text. It has so much information in '.
18.                      'it, that it will definitly not fit into 1 line. Therefore, '.
19.                      'ezcConsoleOutput will automatically wrap the line for us.', 'info' );
21. $output->outputLine();
23. $output->outputLine( 'This verbose information will currently not be displayed.', 'info', 10 );
25. $output->outputLine( 'But this verbose information will be displayed.', 'info', 2 );
27. ?>

autobreak

Will wrap lines automatically after the set amount of characters, keeping word boundaries intact.

verbosityLevel

Allows you to specify a third parameter to ezcConsoleOutput->outputLine() and ezcConsoleOutput->outputText() to indicate a verbosity level for when the text should be printed. By setting the "verbosityLevel" option for ezcConsoleOutput, you define which texts will and will not be printed.

In our example, the call on line 23 would not print out text with the "verbosityLevel" option set to 3, but the call on line 25 would.

The last example shows how to change the target of a format, which allows you to print text e.g. to STDERR.

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $output->formats->error->color = 'red';
8. $output->formats->error->style = array( 'bold' );
9. $output->formats->error->target = ezcConsoleOutput::TARGET_STDERR;
11. $output->outputLine( 'Unable to connect to database', 'error' );
13. ?>

The error message 'Unable to connect to database' will be printed in bold, with a red foreground color to STDOUT. The default target is ezcConsoleOutput::TARGET_OUTPUT, which prints to STDOUT and has standar output buffering in place. If you want to switch out the standard output bufferung, use ezcConsoleOutput::TARGET_STDOUT.

Although this feature was originally not designed for that purpose, you can also use any other arbitrary PHP stream definition as a target. For example 'file:///var/log/my.log' to get the messages redirected to a log file instead of displaying them.

Mastering options and arguments

Below is a simple example for ezcConsoleInput:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $input = new ezcConsoleInput();
7. $helpOption = $input->registerOption( 
8.     new ezcConsoleOption( 
9.         'h',
10.         'help'
11.     )
12. );
14. try
15. {
16.     $input->process();
17. }
18. catch ( ezcConsoleOptionException $e )
19. {
20.     die( $e->getMessage() );
21. }
23. if ( $helpOption->value !== false )
24. {
25.     echo "Help requested.";
26. }
27. else
28. {
29.     echo "No help requested.";
30. }
32. ?>

After instantiating a new ezcConsoleInput object to handle the options, an option is registered on lines 7-12. This option will be available as "-h" and "--help". The ezcConsoleInput->process() call makes ezcConsoleInput respond to the options submitted by the user. If any error occurs with the submitted user data, the method will throw an exception of type ezcConsoleOptionException. By default, all options are registered with the value type ezcConsoleInput::TYPE_NONE, which indicates that they don't expect a value from the user. If a value is submitted anyway, ezcConsoleInput->process() will throw a ezcConsoleOptionTypeViolationException.

On line 23, a check is performed to see whether an option was submitted. If an option was not submitted, its $value property will contain bool false. Depending on the $type set, it can contain different value types if it was submitted. If you use the (not shown here) ezcConsoleOption->$multiple property, the value will be an array containing the specified value types.

The next example is more advanced:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $input = new ezcConsoleInput();
7. $helpOption = $input->registerOption( new ezcConsoleOption( 'h', 'help' ) );
9. $inputOption = $input->registerOption( 
10.     new ezcConsoleOption( 
11.         'i',
12.         'input',
13.         ezcConsoleInput::TYPE_STRING
14.     )
15. );
17. $outputOption = $input->registerOption(
18.     new ezcConsoleOption( 
19.         'o',
20.         'output'
21.     )
22. );
23. $outputOption->type = ezcConsoleInput::TYPE_STRING;
25. $inputOption->addDependency( 
26.     new ezcConsoleOptionRule( $outputOption )
27. );
28. $outputOption->addDependency( 
29.     new ezcConsoleOptionRule( $inputOption )
30. );
32. try
33. {
34.     $input->process();
35. }
36. catch ( ezcConsoleOptionException $e )
37. {
38.     die( $e->getMessage() );
39. }
41. if ( $helpOption->value === true )
42. {
43.     echo $input->getSynopsis() . "\n";
44.     foreach ( $input->getOptions() as $option )
45.     {
46.         echo "-{$option->short}/{$option->long}: {$option->shorthelp}\n";
47.     }
48. }
49. elseif ( $outputOption->value !== false )
50. {
51.     echo "Input: {$inputOption->value}, Output: {$outputOption->value}\n";
52.     echo "Arguments: " . implode( ", ", $input->getArguments() ) . "\n";
53. }
55. ?>

Two options are registered here: "-i" / "--input" and "-o" / "--output". For the first one, additional properties for the ezcConsoleOption object are submitted through the constructor. For the second ezcConsoleOption object, you see how to provide additional properties after construction. We change the type of both options to expect a string value from the user (lines 13 and 20).

In lines 25 and 28 we make both parameters depend on each other. If one of them is submitted without the other, ezcConsoleInput->process() will throw an ezcConsoleOptionDependencyViolationException. Aside from dependency rules, you can also define exclusion rules using ezcConsoleOption->addExclusion().

On line 43, the method ezcConsoleInput->getSynopsis() is used to retrieve a synopsis string for the program. The synopsis for our example would look like this:

The synopsis will indicate the option value types, whether they are optional, the inter-option dependencies and default values (if set). On line 46, the property ezcConsoleOption->$shorthelp is accessed, where you can store some short help information. It has a reasonable default value set.

On line 49, the submission of the "-o" option is checked. Because this has a dependency on the "-i" option, a check for that is not necessary. Line 52 shows how you can access the arguments submitted to the program. ezcConsoleInput->getArguments() always returns an array (which is empty if no arguments are submitted). A more advanced way of handling arguments is explained further below.

Here is an example of how the defined program would be called:

The program would respond by printing the following:

As you can see, this example does not define, which arguments are expected and therefore, the program simply accepts any number of arguments and provides them through the ezcConsoleInput->getArguments() method. The following example shows, how specific arguments can be defined:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $input = new ezcConsoleInput();
7. $helpOption = $input->registerOption( new ezcConsoleOption( 'h', 'help' ) );
8. $helpOption->isHelpOption = true;
10. $input->argumentDefinition = new ezcConsoleArguments();
12. $input->argumentDefinition[0] = new ezcConsoleArgument( "source" );
13. $input->argumentDefinition[0]->shorthelp = "The source directory.";
15. $input->argumentDefinition[1] = new ezcConsoleArgument( "destination" );
16. $input->argumentDefinition[1]->mandatory = false;
17. $input->argumentDefinition[1]->default   = './';
19. $input->argumentDefinition[2] = new ezcConsoleArgument( "iterations" );
20. $input->argumentDefinition[2]->type = ezcConsoleInput::TYPE_INT;
21. $input->argumentDefinition[2]->shorthelp = "Number of iterations.";
22. $input->argumentDefinition[2]->longhelp  = "The number of iterations to perform.";
25. try
26. {
27.     $input->process();
28. }
29. catch ( ezcConsoleException $e )
30. {
31.     die( $e->getMessage() );
32. }
34. if ( $helpOption->value === true )
35. {
36.     echo $input->getHelpText( "A simple text program" );
37. }
38. else
39. {
40.     echo "Source:      {$input->argumentDefinition["source"]->value}\n";
41.     echo "Destination: {$input->argumentDefinition["destination"]->value}\n";
42.     echo "Iterations:  " . ( $input->argumentDefinition["iterations"]->value === null
43.                              ? "not set"
44.                              : $input->argumentDefinition["iterations"]->value
45.                            );
46. }
48. ?>

As seen before, a help option is registered. In addition, 3 arguments are registered: The first one with the name "source" is a standard argument. It is mandatory for the user to submit a value here. The second argument, "destination" is optional and a default value is assigned, which will be used, if the user does not provide a value for it.

The third one ("iterations") is not of type string, but an integer. Because the second argument is optional, this third one is automatically optional, too. Since no default value is assigned, it will be null, if the user does not submit it. If a value is provided, it must be an integer.

Argument definitions are processed as usual inside the ezcConsoleInput->process() method, but will throw an ezcConsoleArgumentException if something goes wrong. If desired, exceptions about options and arguments can be caught together using ezcConsoleException or be handled on their own.

The value of an argument can be fetched from its definition, using its value property. As can be seen at the very end of the example, for reading purpose, arguments can be accessed by their name. This does not work for writing purpose, since a specific order must be given there.

If the --help option is set, mandatory arguments don't need to be submitted and are silently ignored. The help text generated by ezcConsoleInput for this example looks like this:

For further information, please refer to the API documentation of ezcConsoleInput.

Progress indication

This example defines a simple progress bar:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $bar = new ezcConsoleProgressbar( $output, 15 );
9. for ( $i = 0; $i < 15; $i++ )
10. {
11.     $bar->advance();
12.     usleep(  mt_rand( 2000, 200000 ) );
13. }
15. $bar->finish();
17. $output->outputLine();
19. ?>

The created progressbar will count to a maximum value of 15, submitted to ezcConsoleProgressbar->__construct() in line 7. ezcConsoleProgressbar utilizes ezcConsoleOutput to print the generated progress bar. The call to ezcConsoleProgressbar->advance() pushes the progress bar one step further on each call and redraws it (line 11). Calling ezcConsoleProgressbar->finish() will set the progress bar to 100% immediately.

The progress bar generated by the example will look like this:

The next example performs more customization on the progress bar appearance:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $output->formats->bar->color = 'blue';
8. $output->formats->bar->style = array( 'bold' );
10. $options = array( 
11.     'emptyChar'       => ' ',
12.     'barChar'         => '-',
13.     'formatString'    => '%fraction%% <' . $output->formatText( '%bar%', 'bar' ) . '> Uploaded %act% / %max% kb',
14.     'redrawFrequency' => 50,
15. );
17. $bar = new ezcConsoleProgressbar( $output, 1024, $options );
19. for ( $i = 0; $i < 1024; $i++ )
20. {
21.     $bar->advance();
22.     usleep(  mt_rand( 200, 2000 ) );
23. }
25. $bar->finish();
27. $output->outputLine();
29. ?>

The defined options array demonstrates only a small subset of options. For detailed information, see the API documentation on ezcConsoleProgressbarOptions. The "emptyChar" value defines the character to prefill the bar, the "barChar" option defines the character to fill the bar with when calling ezcConsoleProgressbar->advance(). Using the "formatString" option, you define the appearance of the whole bar. Here the substitution of several placeholders (like "%fraction%" and "%bar%") is permitted. "formatString" must contain the "%bar%" placeholder, while all other values are optional. Any other printable character is permitted. Formatting options are allowed in the "formatString" option, but not in any other option. "redrawFrequency" defines how often the progressbar will be redrawn. In the example this will be every 50th call to ezcConsoleProgressbar->advance().

The resulting progress bar looks like this:

With ezcConsoleStatusbar, you can indicate the progress of a time-consuming action in a simpler way. Here is an example:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $output->formats->success->color = 'green';
8. $output->formats->failure->color = 'red';
10. $options = array( 
11.     'successChar' => $output->formatText( '+', 'success' ),
12.     'failureChar' => $output->formatText( '-', 'failure' ),
13. );
15. $status = new ezcConsoleStatusbar( $output, $options );
17. for ( $i = 0; $i < 120; $i++ )
18. {
19.     $nextStatus = ( bool )mt_rand( 0,1 );
20.     $status->add( $nextStatus );
21.     usleep(  mt_rand( 200, 2000 ) );
22. }
24. $output->outputLine();
25. $output->outputLine( 'Successes: ' . $status->getSuccessCount() . ', Failures: ' . $status->getFailureCount() );
27. ?>

This variant of indicating progress only displays success or failure indicators for an action and allows you to run any number of actions, without specifying in advance how many you will perform. The "successChar" and "failureChar" options indicate which string to print on a successful or failed action. Lines 11 and 12 format these strings.

Indicating a status is done using ezcConsoleStatusbar->add(), which expects true for a succeeded action and false for a failed one (line 20). You can access the number of successes and failures through ezcConsoleStatusbar->getSuccessCount() and ezcConsoleStatusbar->getFailureCount(). To make ezcConsoleStatusbar wrap a line after a certain amount of statuses, you can use ezcConsoleOutput->$autobreak.

Here the result of the example:

Finally, ezcConsoleProgressMonitor can indicate progress, but does not use a bar-like interface. It simply prints status information about each action you perform and shows the current progress as a percentage value in relation to the number of actions you plan to perform overall.

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $status = new ezcConsoleProgressMonitor( $output, 7 );
9. $i = 0;
10. while( $i++ < 7 ) 
11. {
12.     usleep( mt_rand( 20000, 2000000 ) );
13.     $status->addEntry( 'ACTION', "Performed action #{$i}." );
14. }
16. $output->outputLine();
18. ?>

Line 7 creates a new status indicator, which will iterate over 7 actions. Inside the while loop, we simulate some actions. The call to $status->addEntry() adds a status entry and causes the indicator to print the entry. Every entry consists of a tag (first parameter) and a message.

The result of the example is as follows:

More information on these classes can be found in the API documentation of ezcConsoleProgressbar, ezcConsoleStatusbar and ezcConsoleProgressMonitor.

Large data served in a table

This is the result of a table generated by ezcConsoleTable:

Here is its corresponding source code:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $data = array( 
6.     array( 'Name', 'Nationality', 'Birthday' ),
7.     array( 'Derick Rethans', 'Dutch', '1978-12-22' ),
8.     array( 'Frederik Holljen', 'Canadian / Norwegian', '1978-11-15' ),
9.     array( 'Jan Borsodi', 'Norwegian', '1977-10-13' ),
10.     array( 'Raymond Bosman', 'Dutch', '1979-07-24' ),
11.     array( 'Tobias Schlitt', 'German', '1980-05-19' ),
12. );
14. $output = new ezcConsoleOutput();
16. $output->formats->headBorder->color = 'blue';
17. $output->formats->normalBorder->color = 'gray';
19. $output->formats->headContent->color = 'blue';
20. $output->formats->headContent->style = array( 'bold' );
22. $table = new ezcConsoleTable( $output, 78 );
24. $table->options->defaultBorderFormat = 'normalBorder';
26. $table[0]->borderFormat = 'headBorder';
27. $table[0]->format = 'headContent';
28. $table[0]->align = ezcConsoleTable::ALIGN_CENTER;
30. foreach ( $data as $row => $cells )
31. {
32.     foreach ( $cells as $cell )
33.     {
34.         $table[$row][]->content = $cell;
35.     }
36. }
38. $output->outputLine( 'eZ components team:' );
39. $table->outputTable();
40. $output->outputLine();
43. ?>

ezcConsoleTable (like ezcConsoleStatusbar and ezcConsoleProgressbar) uses the ezcConsoleOutput class to print to the console. To create a table, you just need to submit the maximum width of the table to its constructor: ezcConsoleTable->__construct(). Options for table formatting are inherited from the table itself to the table rows and from there to the table cells. On each inheritance level, options can be overridden individually. The "defaultBorderFormat" option sets the global format value for all borders (line 24). This is overridden in line 26 for the first row of the table.

Table rows are accessed like an array in PHP (this is achieved by implementing the ArrayAccess interface from SPL). ezcConsoleTable implements the Iterator interface (SPL, too) to allow iteration over table rows using foreach. Each table row is represented by an object of type ezcConsoleTableRow, which also implements the ArrayAccess and Iterator interfaces to access cells contained in the rows in the same way. Each of the named classes allows the access of its properties as usual, in addition to access to its contained objects through the array interface.

ezcConsoleTableRow and ezcConsoleTableCell have a $format setting to define the format of the contained text. All cells (as described above) will inherit the setting of their parent ezcConsoleTableRow, as long as this has not been explicitly overridden. The same applies to ezcConsoleTableRow->$align and ezcConsoleTableCell->$align. Possible align values are:

• ezcConsoleTable::ALIGN_DEFAULT (inherit from parent)

• ezcConsoleTable::ALIGN_LEFT

• ezcConsoleTable::ALIGN_RIGHT

• ezcConsoleTable::ALIGN_CENTER

The content of a cell is stored in the ezcConsoleTableCell->$content property (line 34). The usage of formatted text in a cell is possible, but not recommended. If you want to define the format of cell content, use the ezcConsoleTableCell->$format property.

Below is a more advanced (but in a way useless) example to show the handling of tables:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $output->formats->blue->color  = 'blue';
8. $output->formats->blue->style = array(  'bold' );
9. $output->formats->red->color   = 'red';
10. $output->formats->red->style = array(  'bold' );
11. $output->formats->green->color = 'green';
12. $output->formats->green->style = array(  'bold' );
14. $colors = array( 'red', 'blue', 'green' );
15. $aligns = array( ezcConsoleTable::ALIGN_LEFT, ezcConsoleTable::ALIGN_CENTER, ezcConsoleTable::ALIGN_RIGHT );
17. $table = new ezcConsoleTable( $output, 78 );
19. $table->options->corner = ' ';
20. $table->options->lineHorizontal = ' ';
21. $table->options->lineVertical = ' ';
22. $table->options->widthType = ezcConsoleTable::WIDTH_FIXED;
24. for ( $i = 0; $i < 10; $i++ )
25. {
26.     for ( $j = 0; $j < 10; $j++ )
27.     {
28.         $table[$i][$j]->content = '*';
29.         $table[$i][$j]->format  = $colors[array_rand( $colors )];
30.         $table[$i][$j]->align   = $aligns[array_rand( $aligns )];
31.     }
32. }
34. $table->outputTable();
35. $output->outputLine();
38. ?>

The "corner", "lineHorizontal" and "lineVertical" options define which characters to use for the borders of the table. These options must be exactly one character long and cannot contain formatting information. To style the borders, use the ezcConsoleTable->$defaultBorderFormat and ezcConsoleTableRow->$borderFormat properties.

The random format and alignment options selected above create the following table:

More information on the handling of tables on the shell can be found in the API documentation of ezcConsoleTable, ezcConsoleTableRow and ezcConsoleTableCell.

Interacting with the user

Implementations of the interface ezcConsoleDialog are generic building blocks, which allow to interact with the user of a shell application using STDIN. A dialog is initialized, displayed and will return a value provided by the user. What exactly happens inside a specific dialog may vary. Commonly, the dialog validates and possibly manipulates the provided value before returning it.

The most basic dialog is the ezcConsoleQuestionDialog, which prints out some text and retrieves a single value back.

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $question = new ezcConsoleQuestionDialog( $output );
8. $question->options->text = "Do you want to proceed?";
9. $question->options->showResults = true;
10. $question->options->validator = new ezcConsoleQuestionDialogCollectionValidator(
11.     array( "y", "n" ),
12.     "y",
13.     ezcConsoleQuestionDialogCollectionValidator::CONVERT_LOWER
14. );
16. do
17. {
18.     echo "\nSome action performed...\n\n";
19. }
20. while ( ezcConsoleDialogViewer::displayDialog( $question ) !== "n" );
22. echo "Goodbye!\n";
24. ?>

Every dialog expects an instance of ezcConsoleOutput which is used to display it. The question dialog here will display the text "Do you want to proceed?" and expects an answer from the user. The $showResults option indicates, that the possible values the user may provide will be indicated, as well as the default value, if one is set.

The mechanism for validating the answer is defined by an instance of ezcConsoleQuestionDialogValidator. In the example, a collection validator is used, which defines a collection of valid values. Beside that, it performs a case conversion on the user provided result before validating it, if desired.

Displaying a dialog can either be done directly, by calling ezcConsoleDialog->display(), or the more convenient way, shown in the example. The ezcConsoleDialogViewer::displayDialog() method displays the dialog in a loop, until the user provided a valid value, so that the program can rely on this. In the example, the user is asked after every performed action, if he still wants to proceed. If the answer is "n" or "N", the program stops.

An example run of this application could look like this:

A very similar yes/no question can be created through convenience method very easily:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $question = ezcConsoleQuestionDialog::YesNoQuestion(
8.     $output,
9.     "Do you want to proceed?",
10.     "y"
11. );
13. do
14. {
15.     echo "\nSome action performed...\n\n";
16. }
17. while ( ezcConsoleDialogViewer::displayDialog( $question ) !== "n" );
19. echo "Goodbye!\n";
21. ?>

The created yes/no question dialog contains a custom question and defaults to "y", if nothing is selected. In contrast to the last example, the dialog created here also accepts "yes" and "no" as answers. Both phrases can be used in any typing, e.g. like "yEs" or "NO". This is made possibly by the ezcConsoleQuestionDialogMappingValidator, which extends ezcConsoleQuestionDialogCollectionValidator. The mapping validator allows to define an arbitrary mapping between the user typed answers and expected ones. Therefore the dialog still only returns either "y" or "n".

The second dialog type, provided with ConsoleTools, is the ezcConsoleMenuDialog. Similar to the ezcConsoleQuestionDialog, it displays a list of menu items to the user and requires him to choose one of these. An example for this class looks like this:

1. <?php
3. require_once 'tutorial_autoload.php';
5. $output = new ezcConsoleOutput();
7. $menu = new ezcConsoleMenuDialog( $output );
8. $menu->options = new ezcConsoleMenuDialogOptions();
9. $menu->options->text = "Please choose a possibility:\n";
10. $menu->options->validator = new ezcConsoleMenuDialogDefaultValidator(
11.     array(
12.         "1" => "Perform some more actions",
13.         "2" => "Perform another action",
14.         "0" => "Quit",
15.     ),
16.     "0"
17. );
19. while ( ( $choice = ezcConsoleDialogViewer::displayDialog( $menu ) ) != 0 )
20. {
21.     switch ( $choice )
22.     {
23.         case 1:
24.             echo "Performing some more actions...\n";
25.             break;
26.         case 2:
27.             echo "Performing some other actions!\n";
28.             break;
29.     }
30. }
32. ?>

Again the dialog is instantiated and some options are tweaked to get the desired behaviour. The validator in this case receives an array of possible menu items, while the key represents the identifier and the value contains the text to be displayed for the item. The second argument is the default value, chosen if the user simply presses <return>.

An example run of this program could look like this:

The character used to divide the identifier and text, as well as the text indicating that a selection must be done, can be tweaked, too.

Further information about dialogs can be found in the API documentation of ezcConsoleDialog, ezcConsoleQuestionDialog and ezcConsoleMenuDialog.