Implement --serialize option.

Adjusts tests to maintain full coverage with new feature.

Author: beporter

src/Shell/ConfigReadShell.php

@@ -6,6 +6,7 @@
  */
 namespace ConfigRead\Shell;
 
+use Cake\Console\ConsoleOutput;
 use Cake\Console\Shell;
 use Cake\Core\Configure;
 
@@ -30,6 +31,15 @@ class ConfigReadShell extends Shell {
 	 */
 	public $formatBash = false;
 
+	/**
+	 * Stores command line switch value for whether to serialize all output.
+	 *
+	 * When present, it always overrides the --bash option.
+	 *
+	 * @var bool
+	 */
+	public $formatSerialize = false;
+
 	/**
 	 * Overrides the defaul welcome function in order to supporess the
 	 * normal "Welcome to CakePHP" Cake banner.
@@ -48,6 +58,8 @@ public function _welcome() {
 	public function startup() {
 		parent::startup();
 
+		$this->_io->outputAs(ConsoleOutput::RAW);
+
 		if (isset($this->params['h'])) {
 			return $this->help();
 		}
@@ -61,6 +73,12 @@ public function startup() {
 		if (count($this->args) > 1) {
 			$this->formatBash = true;
 		}
+
+		if (isset($this->params['s'])) {
+			$this->formatSerialize = true;
+			// Make up for Cake snagging the next arg as the value for `-s`.
+			array_unshift($this->args, $this->params['s']);
+		}
 	}
 
 	/**
@@ -71,6 +89,21 @@ public function startup() {
 	 * @return void
 	 */
 	public function main() {
+		if ($this->formatSerialize) {
+			$this->serializedFetchAndPrint();
+		} else {
+			$this->simpleFetchAndPrint();
+		}
+	}
+
+	/**
+	 * Iterate over provided args, printing them to the console as we go.
+	 *
+	 * Used to handle single scalar values and all --bash formatted output.
+	 *
+	 * @return void
+	 */
+	protected function simpleFetchAndPrint() {
 		foreach ($this->args as $key) {
 			$val = $this->fetchVal($key);
 
@@ -82,6 +115,29 @@ public function main() {
 		}
 	}
 
+	/**
+	 * Iterate over provided args, collecting them for serialization.
+	 *
+	 * Used to --serialize formatted output. Returns a single requested
+	 * value as a directly-serialized string. If multiple keys were
+	 * provided on the command line, they are collected into an
+	 * associative array, which is serialized and echoed.
+	 *
+	 * @return void
+	 */
+	protected function serializedFetchAndPrint() {
+		$unserialized = [];
+		foreach ($this->args as $key) {
+			$unserialized[$key] = $this->fetchVal($key);
+		}
+
+		if (count($unserialized) === 1) {
+			$unserialized = array_shift($unserialized);
+		}
+
+		$this->out(serialize($unserialized), 0, Shell::QUIET);
+	}
+
 	/**
 	 * Value fetcher.
 	 *
@@ -147,7 +203,7 @@ protected function printVal($key, $val) {
 			$format = '%1$s=%2$s';
 		}
 
-		$this->out(sprintf($format, $key, $val));
+		$this->out(sprintf($format, $key, $val), 1, Shell::QUIET);
 	}
 
 	/**
@@ -172,6 +228,12 @@ public function getOptionParser() {
 				'default' => false,
 				'help' => __('Always use bash variable deinfition formatting. When enabled, output will be formatted as `KEY_NAME=\'value\'`. This option is auto-enabled if multiple keys are provided on the command line, or if the value for the requested key is itself an array. When multiple values are returned, each will be output on its own line.')
 			))
+			->addOption('serialize', array(
+				'short' => 's',
+				'boolean' => true,
+				'default' => false,
+				'help' => __('Encode all output using PHP\'s `serialize()` method. Makes the Shell\'s output suitable for consumption by other PHP console scripts. Always overrides the --bash option. A single requested key will be serialized directly. Multiple requested keys will be combined into an associative array and then serialized.')
+			))
 			->description(__('Provides CLI access to variables defined in the Configure class of the host
 CakePHP application. Will output the value of any keys passed as arguments.
 Equivelant to `Configure::read(\'Key.Name\')`.'));

tests/TestCase/Shell/ConfigReadShellTest.php

@@ -16,6 +16,14 @@
  * Exposes protected methods for direct testing.
  */
 class TestConfigReadShell extends ConfigReadShell {
+	public function simpleFetchAndPrint() {
+		return parent::simpleFetchAndPrint();
+	}
+
+	public function serializedFetchAndPrint() {
+		return parent::serializedFetchAndPrint();
+	}
+
 	public function fetchVal($key) {
 		return parent::fetchVal($key);
 	}
@@ -82,7 +90,7 @@ public function tearDown() {
 	 * @param string $s The output string being printed.
 	 * @see ::initSUT()
 	 */
-	public function outputCollector($s) {
+	public function outputCollector($s, $newlines = 1, $level = Shell::NORMAL) {
 		$this->output[] = $s;
 	}
 
@@ -233,11 +241,32 @@ public function testStartupBashModeMultiArgs() {
 	}
 
 	/**
-	 * test main().
+	 * Confirm that startup() engages serialized output mode when -s flag is present.
+	 *
+	 * @return void
+	 */
+	public function testStartupSerializeModeFlag() {
+		$this->Shell->params = ['s' => 'canary'];
+
+		$this->Shell->startup();
+		
+		$this->assertEquals(
+			['canary'],
+			$this->Shell->args,
+			'Shell args should contain the value mistakenly captured by the -s option.'
+		);
+		$this->assertTrue(
+			$this->Shell->formatSerialize,
+			'Serialized output formatting should be enabled by the presence of the -s option.'
+		);
+	}
+
+	/**
+	 * test main() using simple (bash) output.
 	 *
 	 * @return void
 	 */
-	public function testMain() {
+	public function testMainSimple() {
 		$expected = [
 			'key' => 'val',
 			'debug' => true,
@@ -261,6 +290,9 @@ public function testMain() {
 				->with($k, $v);
 		}
 
+		// Can't use runCommand() because it requires a host Cake app.
+		//$shell->runCommand(array_keys($expected));
+		// So simulate startup and execution directly:
 		$shell->startup();
 		$shell->main();
 
@@ -271,11 +303,11 @@ public function testMain() {
 	}
 
 	/**
-	 * test main(), including associated protected methods.
+	 * test main(), including associated protected methods, using simple output.
 	 *
 	 * @return void
 	 */
-	public function testMainIntegrationStyle() {
+	public function testMainSimpleIntegration() {
 		$configure = [
 			'key' => 'val',
 			'debug' => true,
@@ -306,4 +338,78 @@ public function testMainIntegrationStyle() {
 			'Bash output should be engaged automatically by presence of multiple command line args.'
 		);
 	}
+
+	/**
+	 * test main(), including associated protected methods, using simple output.
+	 *
+	 * @param array $params Array of params to seed the Shell->params with.
+	 * @param array $args Array of arguments to seed the Shell->args with.
+	 * @param array $expected Array of generated output lines to compare to ::$output.
+	 * @param string $msg Optional PHPUnit assertion failure message.
+	 * @return void
+	 * @dataProvider provideSerializedArgs
+	 */
+	public function testMainSerializedIntegration($params, $args, $expected, $msg = '') {
+		$configure = [
+			'key' => 'val',
+			'debug' => true,
+			'ary' => [
+				'one' => 1,
+				'two' => '2',
+				3 => 'three',
+				'stdClass' => (new \StdClass()),
+			],
+		];
+
+		Configure::write($configure);
+		$this->Shell->params = $params;
+		$this->Shell->args = $args;
+
+		$this->Shell->startup();
+		$this->Shell->main();
+
+		$this->assertEquals(
+			$expected,
+			$this->output,
+			$msg
+		);
+		$this->assertTrue(
+			$this->Shell->formatSerialize,
+			'Serialized output should be engaged from the provided param.'
+		);
+	}
+
+	/**
+	 * Provides input arguments to testMainSerializedIntegration().
+	 *
+	 * All keys named in the [params] and [args] elements must exist in
+	 * $configure as defined in testMainSerializedIntegration() above.
+	 *
+	 * @return void
+	 * @dataProvider provideSerializedArgs
+	 */
+	public function provideSerializedArgs() {
+		return [
+			[
+				['s' => ''], // Params to load in the Shell.
+				[], // Args to load in the Shell.
+				['N;'], // Expected lines of output.
+				'Empty input should produce a serialized `null` string.', // PHPUnit assertion failure message.
+			],
+
+			[
+				['s' => 'key'],
+				[],
+				['s:3:"val";'],
+				'Single scalar value should be serialized directly.',
+			],
+
+			[
+				['s' => 'key'],
+				['ary.stdClass'],
+				['a:2:{s:3:"key";s:3:"val";s:12:"ary.stdClass";O:8:"stdClass":0:{}}'],
+				'Multiple requested keys should be combined into a (serialized) associative array.',
+			],
+		];
+	}
 }