Adds basic special key processing.

Fixes #20 even better.

Author: beporter

README.md

@@ -10,7 +10,7 @@ A CakePHP plugin that provides a Shell to read an app's Configure vars from the
 
 * This is the Cake 3.x version of the plugin, which exists on the `master` branch and is tracked by the `~3.0` semver.
 * For the Cake 2.x version of this plugin, please use the repo's `cake-2.x` branch. (semver `~2.0`)
-* For the Cake 1.3 version, use the `cake-1.3` branch. (semver `~1.0`) **Note:** we don't expect to actively maintain the 1.3 version. It's here because the project started life as a 1.3 Shell.
+* For the Cake 1.3 version, use the `cake-1.3` branch. (semver `~1.0`) **Note:** we don't expect to actively maintain or improve the 1.3 version. It's here because the project started life as a 1.3 Shell.
 
 
 ## Requirements
@@ -50,14 +50,14 @@ To use this plugin, call it from the command line:
 
 ```shell
 $ cd path/to/app/
-$ ./bin/cake ConfigRead Key.Name
+$ ./bin/cake ConfigRead.ConfigRead Key.Name
 'foo'
 ```
 
 ### Format as a bash variable definition
 
 ```shell
-$ ./bin/cake ConfigRead Key.Name Second.Key
+$ ./bin/cake ConfigRead.ConfigRead Key.Name Second.Key
 KEY_NAME='foo'
 SECOND_KEY_FIRST='bar'
 SECOND_KEY_SECOND='baz'
@@ -67,7 +67,7 @@ SECOND_KEY_THIRD='42'
 Note that this format is automatically used whenever more than one key is returned (unless the `--serialize` switch has been used). For example, if you request a key that contains an array, all values in the array will be returned sequentially. Alternatively, if you pass multiple keys on the command line, they will all be returned. The format can also be forced using the `-b` or `--bash` command line switch:
 
 ```shell
-$ ./bin/cake ConfigRead -b Key.Name
+$ ./bin/cake ConfigRead.ConfigRead -b Key.Name
 KEY_NAME='foo'
 ```
 
@@ -80,10 +80,10 @@ Requesting multiple keys on the command line will produce an array of those keys
 This switch always overrides both the `--bash` switch and the Shell's automatic bash formatting.
 
 ```shell
-$ ./bin/cake ConfigRead -s Key.Name Second.Key
+$ ./bin/cake ConfigRead.ConfigRead -s Key.Name Second.Key
 a:2:{s:8:"Key.Name";s:3:"foo";s:10:"Second.Key";a:3:{s:5:"First";s:3:"bar";s:6:"Second";s:3:"baz";s:5:"Third";i:42;}}
 # Check the result by piping into PHP and unserializing the result.
-$ ./bin/cake ConfigRead -s Key.Name Second.Key | php -r 'print_r(unserialize(file_get_contents("php://stdin")));'
+$ ./bin/cake ConfigRead.ConfigRead -s Key.Name Second.Key | php -r 'print_r(unserialize(file_get_contents("php://stdin")));'
 Array
 (
     [Key.Name] => foo
@@ -99,7 +99,7 @@ Array
 ```
 
 
-## Gotchas
+## Potential Gotchas
 
 ### "Consumed" Configure Vars
 
@@ -112,48 +112,9 @@ CakePHP 3 by default "consumes" some of its configs so as not to confused develo
 * Log/Log
 * Security.salt/Security::salt()
 
-The effect is that you can not use the ConfigReadShell to obtain Configure values for any of these keys since they no longer exist in Configure's store. (This is particularly troublesome if you are using [Environment-Aware Configs](https://github.com/beporter/CakePHP-EnvAwareness/tree/master/slides).)
-
-There are two possible workarounds:
-
-1. Use the `ConsoleShell` instead. For example:
-
-	```shell
-	$ echo 'use Cake\Datasource\ConnectionManager; foreach(ConnectionManager::config("default") as $k => $v) { echo "$k=" . escapeshellarg($v) . PHP_EOL; } exit;' | bin/cake Console -q
-	className='Cake\Database\Connection'
-	driver='Cake\Database\Driver\Mysql'
-	persistent=''
-	host='localhost'
-	username='my_app'
-	password='secret'
-	database='my_app'
-	encoding='utf8'
-	timezone='UTC'
-	cacheMetadata='1'
-	quoteIdentifiers=''
-	name='default'
-	```
-
-	This command is wrapped up in our [loadsys/cakephp-shell-scripts](https://github.com/loadsys/CakePHP-Shell-Scripts) repo as the [`db-credentials`](https://github.com/loadsys/CakePHP-Shell-Scripts/blob/76a24/db-credentials) script.
-
-2. Edit your `config/bootstrap.php` to use `Configure::read()` instead of `Configure::consume()`.
-
-	```diff
-	-Cache::config(Configure::consume('Cache'));
-	-ConnectionManager::config(Configure::consume('Datasources'));
-	-Email::configTransport(Configure::consume('EmailTransport'));
-	-Email::config(Configure::consume('Email'));
-	-Log::config(Configure::consume('Log'));
-	-Security::salt(Configure::consume('Security.salt'));
-	+Cache::config(Configure::read('Cache'));
-	+ConnectionManager::config(Configure::read('Datasources'));
-	+Email::configTransport(Configure::read('EmailTransport'));
-	+Email::config(Configure::read('Email'));
-	+Log::config(Configure::read('Log'));
-	+Security::salt(Configure::read('Security.salt'));
-	```
-
-	This will leave the Configure vars in place and allow commands like `bin/cake ConfigRead Datasources.default` to work as expected, but be warned that the values in Configure might not reflect the values actually being used by the various Cake modules.
+The ConfigReadShell devotes about half of its codebase dealing with this for you, allowing you to continue to fetch values using the Configure path (`Datasources.default.host` -> `localhost`) while in the background querying `ConnectionManager::config('default')['host']`. (This is particularly helpful if you are using [Environment-Aware Configs](https://github.com/beporter/CakePHP-EnvAwareness/tree/master/slides).)
+
+The "gotcha" here is that ConfigReadShell has to maintain a static list of Configure keys that are consumed, and how to access them in their new container. **If your app consumes a non-standard Configure key during bootstrapping, you will not be able to obtain it from the ConfigReadShell.**
 
 
 ## Contributing

src/Shell/ConfigReadShell.php

@@ -9,6 +9,7 @@
 use Cake\Console\ConsoleOutput;
 use Cake\Console\Shell;
 use Cake\Core\Configure;
+use Cake\Utility\Hash;
 
 /**
  * ConfigReadShell class.
@@ -40,6 +41,38 @@ class ConfigReadShell extends Shell {
 	 */
 	public $formatSerialize = false;
 
+	/**
+	 * Make the shell aware of "unique" key requests.
+	 *
+	 * Cake 3 uses Configure::consume() on a number of Configure keys to
+	 * prime different Cake modules in `config/boostrap.php`.
+	 *
+	 * Cache::config(Configure::consume('Cache'));
+	 * ConnectionManager::config(Configure::consume('Datasources'));
+	 * Email::configTransport(Configure::consume('EmailTransport'));
+	 * Email::config(Configure::consume('Email'));
+	 * Log::config(Configure::consume('Log'));
+	 * Security::salt(Configure::consume('Security.salt'));
+	 *
+	 * This removes the configs from Configure, making them inaccessible
+	 * through standard means in this Shell.
+	 *
+	 * This property tracks specific key names and the class::method they
+	 * map to so we can perform the correct logic to fetch the values. For
+	 * example, a request for `Cache._cake_core_.className` would result
+	 * in a call like `\Cake\Cache\Cache::config('_cake_core_')['className']`.
+	 *
+	 * @var array
+	 */
+	public $specialKeys = [
+		'Cache' => '\Cake\Cache\Cache::config',
+		'Datasources' => '\Cake\Datasource\ConnectionManager::config',
+		'EmailTransport' => '\Cake\Network\Email\Email::configTransport',
+		'Email' => '\Cake\Network\Email\Email::config',
+		'Log' => '\Cake\Log\Log::config',
+		'Security.salt' => 'self::securitySaltHelper',
+	];
+
 	/**
 	 * Overrides the default welcome function in order to suppress the
 	 * normal "Welcome to CakePHP" banner.
@@ -127,6 +160,24 @@ protected function simpleFetchAndPrint() {
 		}
 	}
 
+	/**
+	 * Value fetch dispatcher.
+	 *
+	 * Checks if the requested key is from a "special" class (that
+	 * normally has its configs `Configure::consume()`d) and routes the
+	 * request to the correct fetcher.
+	 *
+	 * @param string $key The string name of the key to fetch.
+	 * @return mixed The value as obtained from proper fetcher method.
+	 */
+	protected function fetchVal($key) {
+		if ($special = $this->specialKey($key)) {
+			return $this->fetchSpecial($special);
+		} else {
+			return $this->configRead($key);
+		}
+	}
+
 	/**
 	 * Value fetcher.
 	 *
@@ -136,10 +187,121 @@ protected function simpleFetchAndPrint() {
 	 * @param string $key The string name of the key to fetch.
 	 * @return mixed The value as obtained from `Configure::read($key)`.
 	 */
-	protected function fetchVal($key) {
+	protected function configRead($key) {
 		return Configure::read($key);
 	}
 
+	/**
+	 * Determine if the provided key name matches one of our known "special" keys.
+	 *
+	 * If so, return an array of attributes including the callable method
+	 * to fetch values from the class, the config key name to pass (if any)
+	 * and the subkey to extract from the results (if any).
+	 *
+	 * Examples:
+	 *
+	 *   - 'Cache' -->
+	 *     [
+	 *         'callable' => '\Cake\Cache\Cache::config',
+	 *     ]
+	 *     // Will return all available Cache configs.
+	 *
+	 *   - 'Cache.default' -->
+	 *     [
+	 *         'callable' => '\Cake\Cache\Cache::config',
+	 *         'arg' => 'default',
+	 *     ]
+	 *     // Will return  all settings for the `default` Cache.
+	 *
+	 *   - 'Cache.default.className' -->
+	 *     [
+	 *         'callable' => '\Cake\Cache\Cache::config',
+	 *         'arg' => 'default',
+	 *         'subkey' => 'className',
+	 *     ]
+	 *     // Will return only the `className` value for the `default` Cache.
+	 *
+	 * Matching results are fed into ::fetchSpecial().
+	 *
+	 * @param string $search The dotted key name to check against our special keys.
+	 * @return array|false An array containing at least a [callable] key, and possibly [arg] and [subkey] keys. False on no match.
+	 * @see ::fetchSpecial()
+	 */
+	protected function specialKey($search) {
+		$callable = false;
+		foreach ($this->specialKeys as $key => $call) {
+			if (strpos($search, $key) === 0) {
+				$callable = $call;
+			}
+		}
+
+		if (!$callable) {
+			return false;
+		}
+		$special = [
+			'callable' => $callable,
+		];
+
+		$keyParts = explode('.', $search, 3);
+		if (isset($keyParts[1])) {
+			$special['arg'] = $keyParts[1];
+		}
+		if (isset($keyParts[2])) {
+			$special['subkey'] = $keyParts[2];
+		}
+
+		return $special;
+	}
+
+	/**
+	 * Performs necessary gymnastics to fetch "special" configs.
+	 *
+	 * There are three cases to handle:
+	 *
+	 *   1. A "deep" subkey like `Cache.default.className`. In this case,
+	 *      we need to fetch `Cache::config('default')` and then return
+	 *      the ['className'] from the result.
+	 *
+	 *   2. A single config array like `Cache.default. We need to fetch
+	 *      `Cache::config('default')` and return the whole thing.
+	 *
+	 *   3. All configs in a module like `Cache`. In this case we need to
+	 *      try calling `Cache::configured()` (if it exists), then looping
+	 *      over the results using each as a key name for a separate call
+	 *      to `Cache::config($name)` and accumulating all of the results
+	 *      together to return.
+	 *
+	 * @param array $special An array containing at least a [callable] key and possibly [arg] and [subkey]s.
+	 * @return mixed A single scalar value, or an associative array of sub-values.
+	 */
+	protected function fetchSpecial($special) {
+		if (isset($special['arg'])) {
+			$set = call_user_func($special['callable'], $special['arg']);
+		} else {
+			$allConfigCallable = str_replace(
+				'::config',
+				'::configured',
+				$special['callable'],
+				$replaceCount
+			);
+debug($allConfigCallable);
+debug($replaceCount);
+
+			$set = [];
+			if($replaceCount && is_callable($allConfigCallable)) {
+				foreach (call_user_func($allConfigCallable) as $configName) {
+					$set[$configName] = call_user_func($special['callable'], $configName);
+				}
+			}
+		}
+
+		if (isset($special['subkey'])) {
+			return Hash::get($set, $special['subkey']);
+		} else {
+			return $set;
+		}
+	}
+
 	/**
 	 * Recursive output handler.
 	 *
@@ -195,6 +357,25 @@ protected function printVal($key, $val) {
 		$this->out(sprintf($format, $key, $val), 1, Shell::QUIET);
 	}
 
+	/**
+	 * Provides a custom helper for fetching the App's Security.salt value.
+	 *
+	 * The call to Security::salt() method requires no arguments to get the
+	 * current value but we will have split the command line request for
+	 * `Security.salt` into
+	 * `call_user_func('\Cake\Utility\Security::salt', 'salt'). That will
+	 * **set** the salt to `salt` and return "salt" as the new value, which
+	 * isn't what we want. This method exists to be the callable function,
+	 * which itself passes the proper `null` value as the argument, which
+	 * in turn will return the _actual_ salt value.
+	 *
+	 * @param string $salt Because of how this is implemented, this will always be the literal string "salt" and will be ignored.
+	 @return string The result of calling `Security::salt(null);`
+	 */
+	private function securitySaltHelper($salt) {
+		return call_user_func('\Cake\Utility\Security::salt', null);
+	}
+
 	/**
 	 * getOptionParser
 	 *