Refactoring

lib/composer/vendor/consolidation/annotated-command/tests/src/ApplicationWithTerminalWidth.php

@@ -0,0 +1,26 @@
+<?php
+namespace Consolidation\TestUtils;
+
+use Symfony\Component\Console\Application;
+
+class ApplicationWithTerminalWidth extends Application
+{
+    protected $width = 0;
+    protected $height = 0;
+
+    public function __construct($name = 'UNKNOWN', $version = 'UNKNOWN')
+    {
+        parent::__construct($name, $version);
+    }
+
+    public function setWidthAndHeight($width, $height)
+    {
+        $this->width = $width;
+        $this->height = $height;
+    }
+
+    public function getTerminalDimensions()
+    {
+        return [ $this->width, $this->height ];
+    }
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/ExampleAnnotatedCommand.php

@@ -0,0 +1,60 @@
+<?php
+namespace Consolidation\TestUtils;
+
+use Consolidation\AnnotatedCommand\AnnotatedCommand;
+
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * Test file used in the Annotation Factory tests.  It is also
+ * discovered in the testCommandDiscovery() test.
+ *
+ * The testCommandDiscovery test search base is the 'src' directory;
+ * any command files located immediately inside the search base are
+ * eligible for discovery, and will be included in the search results.
+ */
+class ExampleAnnotatedCommand extends AnnotatedCommand
+{
+    /**
+     * Do the main function of the my:cat command.
+     */
+    public function myCat($one, $two = '', $flip = false)
+    {
+        if ($flip) {
+            return "{$two}{$one}";
+        }
+        return "{$one}{$two}";
+    }
+
+    /**
+     * This is the my:cat command implemented as an AnnotatedCommand subclass.
+     *
+     * This command will concatenate two parameters. If the --flip flag
+     * is provided, then the result is the concatenation of two and one.
+     *
+     * @command my:cat
+     * @arg string $one The first parameter.
+     * @arg string $two The other parameter.
+     * @default $two ''
+     * @option boolean $flip Whether or not the second parameter should come first in the result.
+     * @aliases c
+     * @usage bet alpha --flip
+     *   Concatenate "alpha" and "bet".
+     */
+    protected function execute(InputInterface $input, OutputInterface $output)
+    {
+        $one = $input->getArgument('one');
+        $two = $input->getArgument('two');
+        $flip = $input->getOption('flip');
+
+        $result = $this->myCat($one, $two, $flip);
+
+        // We could also just use $output->writeln($result) here,
+        // but calling processResults enables the use of output
+        // formatters. Note also that if you use processResults, you
+        // should correctly inject the command processor into your
+        // annotated command via AnnotatedCommand::setCommandProcessor().
+        return $this->processResults($input, $output, $result);
+    }
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/ExampleCommandFile.php

@@ -0,0 +1,351 @@
+<?php
+namespace Consolidation\TestUtils;
+
+use Consolidation\AnnotatedCommand\CommandData;
+use Consolidation\AnnotatedCommand\AnnotationData;
+use Consolidation\AnnotatedCommand\CommandError;
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Event\ConsoleCommandEvent;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+
+/**
+ * Test file used in the Annotation Factory tests.  It is also
+ * discovered in the testCommandDiscovery() test.
+ *
+ * The testCommandDiscovery test search base is the 'src' directory;
+ * any command files located immediately inside the search base are
+ * eligible for discovery, and will be included in the search results.
+ */
+class ExampleCommandFile
+{
+    protected $state;
+    protected $output;
+
+    public function __construct($state = '')
+    {
+        $this->state = $state;
+    }
+
+    public function setOutput($output)
+    {
+        $this->output = $output;
+    }
+
+    /**
+     * This is the my:cat command
+     *
+     * This command will concatenate two parameters. If the --flip flag
+     * is provided, then the result is the concatenation of two and one.
+     *
+     * @param string $one The first parameter.
+     * @param string $two The other parameter.
+     * @option boolean $flip Whether or not the second parameter should come first in the result.
+     * @aliases c
+     * @usage bet alpha --flip
+     *   Concatenate "alpha" and "bet".
+     * @arbitrary This annotation is here merely as a marker used in testing.
+     */
+    public function myCat($one, $two = '', $options = ['flip' => false])
+    {
+        if ($options['flip']) {
+            return "{$two}{$one}";
+        }
+        return "{$one}{$two}";
+    }
+
+    /**
+     * @command my:repeat
+     */
+    public function myRepeat($one, $two = '', $options = ['repeat' => 1])
+    {
+        return str_repeat("{$one}{$two}", $options['repeat']);
+    }
+
+    /**
+     * @command my:join
+     */
+    public function myJoin(array $args, $options = ['flip' => false, 'repeat' => 1])
+    {
+        if ($options['flip']) {
+            $args = array_reverse($args);
+        }
+        $result = implode('', $args);
+        return str_repeat($result, $options['repeat']);
+    }
+
+    /**
+     * This is a command with no options
+     *
+     * This command will concatenate two parameters.
+     *
+     * @param $one The first parameter.
+     * @param $two The other parameter.
+     * @aliases nope
+     * @usage alpha bet
+     *   Concatenate "alpha" and "bet".
+     */
+    public function commandWithNoOptions($one, $two = 'default')
+    {
+        return "{$one}{$two}";
+    }
+
+    /**
+     * This command has no arguments--only options
+     *
+     * Return a result only if not silent.
+     *
+     * @option silent Supress output.
+     */
+    public function commandWithNoArguments($opts = ['silent|s' => false])
+    {
+        if (!$opts['silent']) {
+            return "Hello, world";
+        }
+    }
+
+    /**
+     * Shortcut on annotation
+     *
+     * This command defines the option shortcut on the annotation instead of in the options array.
+     *
+     * @param $opts The options
+     * @option silent|s Supress output.
+     */
+    public function shortcutOnAnnotation($opts = ['silent' => false])
+    {
+        if (!$opts['silent']) {
+            return "Hello, world";
+        }
+    }
+
+    /**
+     * This is the test:arithmatic command
+     *
+     * This command will add one and two. If the --negate flag
+     * is provided, then the result is negated.
+     *
+     * @command test:arithmatic
+     * @param integer $one The first number to add.
+     * @param integer $two The other number to add.
+     * @option negate Whether or not the result should be negated.
+     * @aliases arithmatic
+     * @usage 2 2 --negate
+     *   Add two plus two and then negate.
+     * @custom
+     */
+    public function testArithmatic($one, $two, $options = ['negate' => false])
+    {
+        $result = $one + $two;
+        if ($options['negate']) {
+            $result = -$result;
+        }
+
+        // Integer return codes are exit codes (errors), so
+        // return a the result as a string so that it will be printed.
+        return "$result";
+    }
+
+    /**
+     * This is the test:state command
+     *
+     * This command tests to see if the state of the Commandfile instance
+     */
+    public function testState()
+    {
+        return $this->state;
+    }
+
+    /**
+     * This is the test:passthrough command
+     *
+     * This command takes a variable number of parameters as
+     * an array and returns them as a csv.
+     */
+    public function testPassthrough(array $params)
+    {
+        return implode(',', $params);
+    }
+
+    /**
+     * This command wraps its parameter in []; its alter hook
+     * then wraps the result in <>.
+     */
+    public function testHook($parameter)
+    {
+        return "[$parameter]";
+    }
+
+    /**
+     * Wrap the results of test:hook in <>.
+     *
+     * @hook alter test:hook
+     */
+    public function hookTestHook($result)
+    {
+        return "<$result>";
+    }
+
+    /**
+     * This test is very similar to the preceding test, except
+     * it uses an annotation hook instead of a named-function hook.
+     *
+     * @hookme
+     * @before >
+     * @after <
+     */
+    public function testAnnotationHook($parameter)
+    {
+        return "($parameter)";
+    }
+
+    /**
+     * Wrap the results of test:hook in whatever the @before and @after
+     * annotations contain.
+     *
+     * @hook alter @hookme
+     */
+    public function hookTestAnnotatedHook($result, CommandData $commandData)
+    {
+        $before = $commandData->annotationData()->get('before', '-');
+        $after = $commandData->annotationData()->get('after', '-');
+        return "$before$result$after";
+    }
+
+    /**
+     * Alter the results of the hook with its command name.
+     *
+     * @hook alter @addmycommandname
+     */
+    public function hookAddCommandName($result, CommandData $commandData)
+    {
+        $annotationData = $commandData->annotationData();
+        return "$result from " . $annotationData['command'];
+    }
+
+    /**
+     * Here is a hook with an explicit command annotation that we will alter
+     * with the preceeding hook
+     *
+     * @command alter-me
+     * @addmycommandname
+     */
+    public function alterMe()
+    {
+        return "splendiferous";
+    }
+
+    /**
+     * Here is another hook that has no command annotation that should be
+     * altered with the default value for the command name
+     *
+     * @addmycommandname
+     */
+    public function alterMeToo()
+    {
+        return "fantabulous";
+    }
+
+    /**
+     * @hook pre-command test:post-command
+     */
+    public function hookTestPreCommandHook(CommandData $commandData)
+    {
+        // Use 'writeln' to detect order that hooks are called
+        $this->output->writeln("foo");
+    }
+
+    /**
+     * @command test:post-command
+     */
+    public function testPostCommand($value)
+    {
+        $this->output->writeln($value);
+    }
+
+    /**
+     * @hook post-command test:post-command
+     */
+    public function hookTestPostCommandHook($result, CommandData $commandData)
+    {
+        // Use 'writeln' to detect order that hooks are called
+        $this->output->writeln("baz");
+    }
+
+    public function testHello($who)
+    {
+        return "Hello, $who.";
+    }
+
+    public function testException($what)
+    {
+        throw new \Exception($what);
+    }
+
+    /**
+     * @hook init test:hello
+     */
+    public function initializeTestHello($input, AnnotationData $annotationData)
+    {
+        $who = $input->getArgument('who');
+        if (!$who) {
+            $input->setArgument('who', 'Huey');
+        }
+    }
+
+    /**
+     * @hook command-event test:hello
+     */
+    public function commandEventTestHello(ConsoleCommandEvent $event)
+    {
+        // Note that Symfony Console will not allow us to alter the
+        // input from this hook, so we'll just print something to
+        // show that this hook was executed.
+        $input = $event->getInput();
+        $who = $input->getArgument('who');
+        $this->output->writeln("Here comes $who!");
+    }
+
+    /**
+     * @hook interact test:hello
+     */
+    public function interactTestHello($input, $output)
+    {
+        $who = $input->getArgument('who');
+        if (!$who) {
+            $input->setArgument('who', 'Goofey');
+        }
+    }
+
+    /**
+     * @hook validate test:hello
+     */
+    public function validateTestHello($commandData)
+    {
+        $args = $commandData->arguments();
+        if ($args['who'] == 'Donald Duck') {
+            return new CommandError("I won't say hello to Donald Duck.");
+        }
+        if ($args['who'] == 'Drumph') {
+            throw new \Exception('Irrational value error.');
+        }
+    }
+
+    /**
+     * Test default values in arguments
+     *
+     * @param string|null $one
+     * @param string|null $two
+     * @return string
+     */
+    public function defaults($one = null, $two = null)
+    {
+        if ($one && $two) {
+            return "$one and $two";
+        }
+        if ($one) {
+            return "only $one";
+        }
+        return "nothing provided";
+    }
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/ExampleCommandInfoAlterer.php

@@ -0,0 +1,15 @@
+<?php
+namespace Consolidation\TestUtils;
+
+use Consolidation\AnnotatedCommand\Parser\CommandInfo;
+use Consolidation\AnnotatedCommand\CommandInfoAltererInterface;
+
+class ExampleCommandInfoAlterer implements CommandInfoAltererInterface
+{
+    public function alterCommandInfo(CommandInfo $commandInfo, $commandFileInstance)
+    {
+        if ($commandInfo->hasAnnotation('arbitrary')) {
+            $commandInfo->addAnnotation('dynamic', "This annotation was dynamically added by ExampleCommandInfoAlterer");
+        }
+    }
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/ExampleHookAllCommandFile.php

@@ -0,0 +1,41 @@
+<?php
+namespace Consolidation\TestUtils;
+
+use Symfony\Component\Console\Command\Command;
+use Symfony\Component\Console\Input\InputInterface;
+use Symfony\Component\Console\Output\OutputInterface;
+use Consolidation\AnnotatedCommand\CommandError;
+use Consolidation\AnnotatedCommand\AnnotationData;
+
+/**
+ *
+ */
+class ExampleHookAllCommandFile
+{
+    public function doCat($one, $two = '', $options = ['flip' => false])
+    {
+        if ($options['flip']) {
+            return "{$two}{$one}";
+        }
+        return "{$one}{$two}";
+    }
+
+    public function doRepeat($one, $two = '', $options = ['repeat' => 1])
+    {
+        return str_repeat("{$one}{$two}", $options['repeat']);
+    }
+
+    /**
+     * This hook function does not specify which command or annotation
+     * it is hooking; that makes it apply to every command in the same class.
+     *
+     * @hook alter
+     */
+    public function alterAllCommands($result)
+    {
+        if (is_string($result)) {
+            $result = "*** $result ***";
+        }
+        return $result;
+    }
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/alpha/AlphaCommandFile.php

@@ -0,0 +1,243 @@
+<?php
+namespace Consolidation\TestUtils\alpha;
+
+use Consolidation\AnnotatedCommand\CommandError;
+use Consolidation\OutputFormatters\StructuredData\RowsOfFields;
+use Consolidation\OutputFormatters\StructuredData\AssociativeList;
+use Consolidation\AnnotatedCommand\AnnotationData;
+use Symfony\Component\Console\Input\InputOption;
+use Consolidation\AnnotatedCommand\CommandData;
+
+/**
+ * Test file used in the testCommandDiscovery() test.
+ *
+ * This commandfile is found by the test.  The test search base is the
+ * 'src' directory, and 'alpha' is one of the search directories available
+ * for searching.
+ */
+class AlphaCommandFile
+{
+    /**
+     * @command always:fail
+     */
+    public function alwaysFail()
+    {
+        return new CommandError('This command always fails.', 13);
+    }
+
+    /**
+     * @command simulated:status
+     */
+    public function simulatedStatus()
+    {
+        return ['status-code' => 42];
+    }
+
+    /**
+     * @command example:output
+     */
+    public function exampleOutput()
+    {
+        return 'Hello, World.';
+    }
+
+    /**
+     * @command example:cat
+     */
+    public function exampleCat($one, $two = '', $options = ['flip' => false])
+    {
+        if ($options['flip']) {
+            return "{$two}{$one}";
+        }
+        return "{$one}{$two}";
+    }
+
+    /**
+     * @command example:echo
+     */
+    public function exampleEcho(array $args)
+    {
+        return ['item-list' => $args];
+    }
+
+    /**
+     * @command example:message
+     */
+    public function exampleMessage()
+    {
+        return ['message' => 'Shipwrecked; send bananas.'];
+    }
+
+    /**
+     * Test command with formatters
+     *
+     * @command example:table
+     * @field-labels
+     *   first: I
+     *   second: II
+     *   third: III
+     * @usage example:table --format=yaml
+     * @usage example:table --format=csv
+     * @usage example:table --fields=first,third
+     * @usage example:table --fields=III,II
+     * @return \Consolidation\OutputFormatters\StructuredData\RowsOfFields
+     */
+    public function exampleTable($options = ['format' => 'table', 'fields' => ''])
+    {
+        $outputData = [
+            [ 'first' => 'One',  'second' => 'Two',  'third' => 'Three' ],
+            [ 'first' => 'Eins', 'second' => 'Zwei', 'third' => 'Drei'  ],
+            [ 'first' => 'Ichi', 'second' => 'Ni',   'third' => 'San'   ],
+            [ 'first' => 'Uno',  'second' => 'Dos',  'third' => 'Tres'  ],
+        ];
+        return new RowsOfFields($outputData);
+    }
+
+    /**
+     * Test word wrapping
+     *
+     * @command example:wrap
+     * @field-labels
+     *   first: First
+     *   second: Second
+     *
+     * @return \Consolidation\OutputFormatters\StructuredData\RowsOfFields
+     */
+    public function exampleWrap()
+    {
+        $data = [
+            [
+                'first' => 'This is a really long cell that contains a lot of data. When it is rendered, it should be wrapped across multiple lines.',
+                'second' => 'This is the second column of the same table. It is also very long, and should be wrapped across multiple lines, just like the first column.',
+            ]
+        ];
+        return new RowsOfFields($data);
+    }
+
+    /**
+     * @hook option example:table
+     */
+    public function additionalOptionForExampleTable($command, $annotationData)
+    {
+        $command->addOption(
+            'dynamic',
+            '',
+            InputOption::VALUE_NONE,
+            'Option added by @hook option example:table'
+        );
+    }
+
+    /**
+     * Demonstrate an alter hook with an option
+     *
+     * @hook alter example:table
+     * @option french Add a row with French numbers.
+     * @usage example:table --french
+     */
+    public function alterFormatters($result, CommandData $commandData)
+    {
+        if ($commandData->input()->getOption('french')) {
+            $result[] = [ 'first' => 'Un',  'second' => 'Deux',  'third' => 'Trois'  ];
+        }
+
+        return $result;
+    }
+
+    /**
+     * Test command with formatters using an associative list
+     *
+     * @command example:list
+     * @field-labels
+     *   sftp_command: SFTP Command
+     *   sftp_username: SFTP Username
+     *   sftp_host: SFTP Host
+     *   sftp_password: SFTP Password
+     *   sftp_url: SFTP URL
+     *   git_command: Git Command
+     *   git_username: Git Username
+     *   git_host: Git Host
+     *   git_port: Git Port
+     *   git_url: Git URL
+     *   mysql_command: MySQL Command
+     *   mysql_username: MySQL Username
+     *   mysql_host: MySQL Host
+     *   mysql_password: MySQL Password
+     *   mysql_url: MySQL URL
+     *   mysql_port: MySQL Port
+     *   mysql_database: MySQL Database
+     *   redis_command: Redis Command
+     *   redis_port: Redis Port
+     *   redis_url: Redis URL
+     *   redis_password: Redis Password
+     * @default-fields *_command
+     * @return \Consolidation\OutputFormatters\StructuredData\AssociativeList
+     */
+    public function exampleAssociativeList()
+    {
+        $outputData = [
+            'sftp_command' => 'sftp -o Port=2222 dev@appserver.dev.drush.in',
+            'sftp_username' => 'dev',
+            'sftp_host' => 'appserver.dev.drush.in',
+            'sftp_password' => 'Use your account password',
+            'sftp_url' => 'sftp://dev@appserver.dev.drush.in:2222',
+            'git_command' => 'git clone ssh://codeserver.dev@codeserver.dev.drush.in:2222/~/repository.git wp-update',
+            'git_username' => 'codeserver.dev',
+            'git_host' => 'codeserver.dev.drush.in',
+            'git_port' => 2222,
+            'git_url' => 'ssh://codeserver.dev@codeserver.dev.drush.in:2222/~/repository.git',
+            'mysql_command' => 'mysql -u pantheon -p4b33cb -h dbserver.dev.drush.in -P 16191 pantheon',
+            'mysql_username' => 'pantheon',
+            'mysql_host' => 'dbserver.dev.drush.in',
+            'mysql_password' => '4b33cb',
+            'mysql_url' => 'mysql://pantheon:4b33cb@dbserver.dev.drush.in:16191/pantheon',
+            'mysql_port' => 16191,
+            'mysql_database' => 'pantheon',
+        ];
+        return new AssociativeList($outputData);
+    }
+
+    /**
+     * This command has no annotations; this means that it will not be
+     * found when createCommandsFromClass() is called with
+     * '$includeAllPublicMethods' set to false.
+     */
+    public function withoutAnnotations()
+    {
+        return 'ok';
+    }
+
+    /**
+     * @command command:with-one-optional-argument
+     *
+     * This command has just one optional argument.
+     *
+     * Return a result only if not silent.
+     *
+     * @option silent Supress output.
+     */
+    public function commandWithOneOptionalArgument($who = 'world', $opts = ['silent|s' => false])
+    {
+        if (!$opts['silent']) {
+            return "Hello, $who";
+        }
+    }
+
+    /**
+     * This should be a command, because it is annotated like one.
+     *
+     * @command get:serious
+     */
+    public function getSerious()
+    {
+        return 'very serious';
+    }
+
+    /**
+     * This should not be a command, because it looks like an accessor and
+     * has no @command annotation.
+     */
+    public function getLost()
+    {
+        return 'very lost';
+    }
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/alpha/Exclude/ExcludedCommandFile.php

@@ -0,0 +1,14 @@
+<?php
+namespace Consolidation\TestUtils\alpha\Exclude;
+
+/**
+ * Test file used in the testCommandDiscovery() test.
+ *
+ * This commandfile is NOT found by the test.  It is in a searched
+ * location (@see Consolidation\TestUtils\alpha\Exclude\IncludedCommandFile),
+ * but it is in a folder named 'Exclude', which is excluded form search.
+ */
+class ExcludedCommandFile
+{
+
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/alpha/Inclusive/IncludedCommandFile.php

@@ -0,0 +1,16 @@
+<?php
+namespace Consolidation\TestUtils\alpha\Inclusive;
+
+/**
+ * Test file used in the testCommandDiscovery() test.
+ *
+ * This commandfile is found by the test.  The test search base is the
+ * 'src' directory, and 'alpha' is one of the search directories available
+ * for searching.  Directories such as this in the search locations list
+ * are searched deeply (to a depth of two), so command files may be
+ * organized into sub-namespaces, if desired.
+ */
+class IncludedCommandFile
+{
+
+}

lib/composer/vendor/consolidation/annotated-command/tests/src/beta/BetaCommandFile.php

@@ -0,0 +1,52 @@
+<?php
+namespace Consolidation\TestUtils\beta;
+
+use Consolidation\AnnotatedCommand\AnnotationData;
+use Consolidation\AnnotatedCommand\CommandData;
+
+/**
+ * Test file used in the testCommandDiscovery() test.
+ *
+ * This commandfile is not found by the test.  The test search base is the
+ * 'src' directory, but 'beta' is NOT one of the search directories available
+ * for searching, so nothing in this folder will be examined.
+ */
+class BetaCommandFile
+{
+    public function unavailableCommand()
+    {
+        return 'This command is not available, because this commandfile is not in a location that is searched by the tests.';
+    }
+
+    /**
+     * Demonstrate an alter hook with an option
+     *
+     * @hook alter example:table
+     * @option chinese Add a row with Chinese numbers.
+     * @usage example:table --chinese
+     */
+    public function alterFormattersChinese($result, CommandData $commandData)
+    {
+        if ($commandData->input()->getOption('chinese')) {
+            $result[] = [ 'first' => '壹',  'second' => '貳',  'third' => '叁'  ];
+        }
+
+        return $result;
+    }
+
+    /**
+     * Demonstrate an alter hook with an option
+     *
+     * @hook alter *
+     * @option kanji Add a row with Kanji numbers.
+     * @usage example:table --kanji
+     */
+    public function alterFormattersKanji($result, CommandData $commandData)
+    {
+        if ($commandData->input()->getOption('kanji')) {
+            $result[] = [ 'first' => '一',  'second' => '二',  'third' => '三'  ];
+        }
+
+        return $result;
+    }
+}