/**
  * Save a template with the current params. Writes file to `Create::$path`.
  * Override default save to add timestamp in file name.
  *
  * @param array $params
  * @return string A result string on success of writing the file. If any errors occur along
  *         the way such as missing information boolean false is returned.
  */
 protected function _save(array $params = array())
 {
     $defaults = array('namespace' => null, 'class' => null);
     $params += $defaults;
     if (empty($params['class']) || empty($this->_library['path'])) {
         return false;
     }
     $contents = $this->_template();
     $result = String::insert($contents, $params);
     $namespace = str_replace($this->_library['prefix'], '\\', $params['namespace']);
     $date = date('YmdHis');
     $path = str_replace('\\', '/', "{$namespace}\\{$date}_{$params['class']}");
     $path = $this->_library['path'] . stristr($path, '/');
     $file = str_replace('//', '/', "{$path}.php");
     $directory = dirname($file);
     $relative = str_replace($this->_library['path'] . '/', "", $file);
     if (!is_dir($directory) && !mkdir($directory, 0755, true)) {
         return false;
     }
     if (file_exists($file)) {
         $prompt = "{$relative} already exists. Overwrite?";
         $choices = array('y', 'n');
         if ($this->in($prompt, compact('choices')) !== 'y') {
             return "{$params['class']} skipped.";
         }
     }
     if (file_put_contents($file, "<?php\n\n{$result}\n\n?>")) {
         return "{$params['class']} created in {$relative}.";
     }
     return false;
 }

 /**
  * Generate hashed and salted token from `'prefix'` and `md5` hashed `$email` value
  * @param $email string User email that will be used as base for secret token
  * @param array $options Supported options:
  *        - `'prefix'` _string|int_ If not passed this method will generate random int from
  *          `100000` to `999999`. Hashed email will be prefixed with value of this option.
  *          Example: `'prefix_value' . md5($email)`
  *        - All other options are same as `lithium\util\String::hash()`
  * @return string Hashed prefixed email salted and hashed again
  * @see lithium\util\String::hash()
  */
 public static function generate($email, array $options = array())
 {
     $options += array('prefix' => null, 'salt' => LI3_UM_TokenSalt, 'type' => 'sha256');
     $prefix = $options['prefix'] ? $options['prefix'] : mt_rand(100000, 999999);
     unset($options['prefix']);
     return String::hash($prefix . md5($email), $options);
 }

 /**
  * Override the save method to handle view specific params.
  *
  * @param array $params
  * @return mixed
  */
 protected function _save(array $params = array())
 {
     $params['path'] = Inflector::underscore($this->request->action);
     $params['file'] = $this->request->args(0);
     $contents = $this->_template();
     $result = String::insert($contents, $params);
     if (!empty($this->_library['path'])) {
         $path = $this->_library['path'] . "/views/{$params['path']}/{$params['file']}";
         $file = str_replace('//', '/', "{$path}.php");
         $directory = dirname($file);
         if (!is_dir($directory)) {
             if (!mkdir($directory, 0755, true)) {
                 return false;
             }
         }
         $directory = str_replace($this->_library['path'] . '/', '', $directory);
         if (file_exists($file)) {
             $prompt = "{$file} already exists. Overwrite?";
             $choices = array('y', 'n');
             if ($this->in($prompt, compact('choices')) !== 'y') {
                 return "{$params['file']} skipped.";
             }
         }
         if (is_int(file_put_contents($file, $result))) {
             return "{$params['file']}.php created in {$directory}.";
         }
     }
     return false;
 }

 /**
  * Obtain the session key.
  *
  * For this adapter, it is a UUID based on the SERVER_ADDR variable.
  *
  * @return string UUID.
  */
 public static function key()
 {
     $context = function ($value) use(&$config) {
         return isset($_SERVER['SERVER_ADDR']) ? $_SERVER['SERVER_ADDR'] : '127.0.0.1';
     };
     return String::uuid($context);
 }

 public static function addModules($modules)
 {
     $modules = (array) $modules;
     $calledClass = get_called_class();
     $baseClassName = array_pop(explode('\\', $calledClass));
     if (!isset(self::$_modules[$calledClass])) {
         self::$_modules[$calledClass] = array();
     }
     foreach ($modules as $name => $config) {
         if (is_integer($name) and is_string($config)) {
             $name = $config;
             $config = array();
         }
         $current = isset(self::$_modules[$calledClass][$name]) ? self::$_modules[$calledClass][$name] : ($current = array());
         $defaults = array('class' => String::insert('\\app\\modules\\{:class}\\{:name}Module', array('class' => $baseClassName, 'name' => ucfirst($name))), 'partial' => String::insert('modules/{:class}/{:name}', array('class' => $baseClassName, 'name' => $name)));
         self::$_modules[$calledClass][$name] = $config + $defaults + $current;
         if (!class_exists(self::$_modules[$calledClass][$name]['class'])) {
             throw new \Exception('Module class ' . self::$_modules[$calledClass][$name]['class'] . ' not found.');
         }
         if (isset($config['filters'])) {
             foreach ($config['filters'] as $function => $filter) {
                 static::applyFilter($function, $filter);
             }
         }
     }
     return true;
 }

 /**
  * Process incoming messages
  *
  * @param string $data
  * @return string
  */
 public function process($data)
 {
     $responses = $this->_responses;
     $model = $this->_classes['model'];
     $location = null;
     extract($data);
     $words = preg_split("/[\\s]/", $message, 2);
     if ($words[0] != '~weather') {
         return;
     }
     if (!isset($words[1])) {
         return String::insert($responses['missing'], compact('user'));
     }
     $location = $model::find('search', $words[1]);
     if (!$location || isset($location->title)) {
         return String::insert($responses['unknown'], compact('user') + array('location' => $words[1]));
     }
     if (isset($location->location)) {
         $location = $model::find('search', $location->location[0]->name);
         if (!$location || isset($location->title)) {
             return String::insert($responses['unknown'], compact('user') + array('location' => $words[1]));
         }
     }
     $station = $location->nearby_weather_stations->airport->station[0];
     $weather = $model::find('station', (string) $station->icao);
     if (!$weather || isset($weather->title)) {
         return String::insert($responses['unknown'], compact('user') + array('location', $words[1]));
     }
     return String::insert($responses['weather'], compact('user') + array('city' => (string) $station->city, 'state' => (string) $station->state, 'country' => (string) $station->country, 'icao' => (string) $station->icao, 'temperature' => (string) $weather->temperature_string, 'windchill' => (string) $weather->windchill_string, 'wind' => (string) $weather->wind_string));
 }

 /**
  * With lots of various rules we created 4 various rulesets for operators. If one
  * of the tokens or content is found we use the given regex on the joined array.
  *
  * @param  Testable $testable The testable object
  * @return void
  */
 public function apply($testable, array $config = array())
 {
     $tokens = $testable->tokens();
     foreach ($this->inspector as $inspector) {
         if (isset($inspector['tokens'])) {
             $byToken = $testable->findAll($inspector['tokens']);
         } else {
             $byToken = array();
         }
         if (isset($inspector['content'])) {
             $byContent = $testable->findAllContent($inspector['content']);
         } else {
             $byContent = array();
         }
         foreach (array_merge($byToken, $byContent) as $id) {
             $token = $tokens[$id];
             $isPHP = $testable->isPHP($token['line']);
             if ($isPHP && empty($token['isString'])) {
                 $pattern = String::insert($inspector['regex'], array('content' => preg_quote($token['content'], "/")));
                 $firstId = $id - $inspector['relativeTokens']['before'];
                 $firstId = $firstId < 0 ? 0 : $firstId;
                 $length = $inspector['relativeTokens']['length'];
                 $inspectTokens = array_slice($tokens, $firstId, $length);
                 $html = null;
                 foreach ($inspectTokens as $htmlToken) {
                     $html .= $htmlToken['content'];
                 }
                 if (preg_match($pattern, $html) === 0) {
                     $this->addViolation(array('message' => String::insert($inspector['message'], $token), 'line' => $token['line']));
                 }
             }
         }
     }
 }

 /**
  * Process incoming messages.
  *
  * @param string $data
  * @return string
  */
 public function process($data)
 {
     $model = $this->_classes['model'];
     extract($data);
     if ($message[0] != '~') {
         return;
     }
     list($command, $recipient) = preg_split("/[\\s]/", $message, 2) + array(null, null);
     if (!($recipient = trim($recipient))) {
         return;
     }
     if ($command == '~inc') {
         if ($recipient == $user) {
             return String::insert($this->_responses['self'], compact('user'));
         }
         $model::increment($recipient);
         $current = $model::current($recipient);
         return String::insert($this->_responses['update'], compact('recipient', 'current'));
     } elseif ($command == '~dec') {
         if ($model::current($recipient) == 0) {
             return String::insert($this->_responses['decrementFail'], compact('recipient'));
         }
         $model::decrement($recipient);
         $current = $model::current($recipient);
         return String::insert($this->_responses['update'], compact('recipient', 'current'));
     } elseif ($command == '~karma') {
         $current = $model::current($recipient);
         return String::insert($this->_responses['current'], compact('recipient', 'current'));
     }
 }

 public function url($url, array $options = [])
 {
     $absolute = static::_url();
     return function ($self, $params) use($url, $absolute, $options) {
         $style = ['style' => $options['key']];
         return $absolute . String::insert($url, $style);
     };
 }

 /**
  * Constructor.
  *
  * @param array $config Configuration options.
  */
 public function __construct(array $config = array())
 {
     $defaults = array('scheme' => 'https', 'host' => '{:login}.freshbooks.com', 'port' => null, 'login' => null, 'password' => '', 'auth' => 'Basic', 'version' => '1.1', 'path' => '/api/2.1');
     $config += $defaults;
     $config['host'] = String::insert($config['host'], $config);
     $config['login'] = $config['password'];
     $config['password'] = 'x';
     parent::__construct($config);
 }

 public function interpolate($file)
 {
     $styles = $this->_config['styles'];
     $return = [];
     foreach ($styles as $style => $dimension) {
         $return[$dimension] = String::insert($file, ['style' => $style]);
     }
     return $return;
 }

 protected function _paths($type, array $params)
 {
     if (!isset($this->_paths[$type])) {
         throw new TemplateException("Invalid template type '{$type}'.");
     }
     return array_map(function ($path) use($params) {
         return String::insert($path, $params);
     }, (array) $this->_paths[$type]);
 }

 protected function _render($method, $string, $params, $options = array())
 {
     $defaults = array();
     $options += $defaults;
     foreach ($params as $key => $value) {
         $params[$key] = $this->_context->applyHandler($this, $method, $key, $value, $options);
     }
     $strings = $this->_context ? $this->_context->strings() : $this->_strings;
     return String::insert(isset($strings[$string]) ? $strings[$string] : $string, $params);
 }

 public static function __init()
 {
     parent::__init();
     static::applyFilter('create', function ($self, $params, $chain) {
         if (empty($params['data']['id'])) {
             $params['data']['id'] = String::uuid();
         }
         return $chain->next($self, $params, $chain);
     });
 }

 /**
  * Will iterate over each line checking if any weak comparison operators
  * are used within the code.
  *
  * @param  Testable $testable The testable object
  * @return void
  */
 public function apply($testable, array $config = array())
 {
     $tokens = $testable->tokens();
     $message = 'Weak comparison operator {:key} used, try {:value} instead';
     $filtered = $testable->findAll(array_keys($this->inspectableTokens));
     foreach ($filtered as $id) {
         $token = $tokens[$id];
         $this->addWarning(array('message' => String::insert($message, array('key' => token_name($token['id']), 'value' => $this->inspectableTokens[$token['id']])), 'line' => $token['line']));
     }
 }

 /**
  * Renders content from a template file provided by `template()`.
  *
  * @param string $template
  * @param array $data
  * @param array $options
  * @return string
  */
 public function render($template, $data = array(), $options = array())
 {
     $context = array();
     $this->_context = $options['context'] + $this->_context;
     foreach (array_keys($this->_context) as $key) {
         $context[$key] = $this->__get($key);
     }
     $data = array_merge($this->_toString($context), $this->_toString($data));
     return String::insert($template, $data, $options);
 }

 /**
  * Appends a message to a log file.
  *
  * @see lithium\analysis\Logger::$_priorities
  * @param string $priority The message priority. See `Logger::$_priorities`.
  * @param string $message The message to write to the log.
  * @return \Closure Function returning boolean `true` on successful write, `false` otherwise.
  */
 public function write($priority, $message)
 {
     $config = $this->_config;
     return function ($self, $params) use(&$config) {
         $path = $config['path'] . '/' . $config['file']($params, $config);
         $params['timestamp'] = date($config['timestamp']);
         $message = String::insert($config['format'], $params);
         return file_put_contents($path, $message, FILE_APPEND);
     };
 }

 /**
  * Outputs a stack trace based on the supplied options.
  *
  * @param array $options Format for outputting stack trace. Available options are:
  *        - `'args'`: A boolean indicating if arguments should be included.
  *        - `'depth'`: The maximum depth of the trace.
  *        - `'format'`: Either `null`, `'points'` or `'array'`.
  *        - `'includeScope'`: A boolean indicating if items within scope
  *           should be included.
  *        - `'scope'`: Scope for items to include.
  *        - `'start'`: The depth to start with.
  *        - `'trace'`: A trace to use instead of generating one.
  * @return string|array|null Stack trace formatted according to `'format'` option.
  */
 public static function trace(array $options = array())
 {
     $defaults = array('depth' => 999, 'format' => null, 'args' => false, 'start' => 0, 'scope' => array(), 'trace' => array(), 'includeScope' => true, 'closures' => true);
     $options += $defaults;
     $backtrace = $options['trace'] ?: debug_backtrace();
     $scope = $options['scope'];
     $count = count($backtrace);
     $back = array();
     $traceDefault = array('line' => '??', 'file' => '[internal]', 'class' => null, 'function' => '[main]');
     for ($i = $options['start']; $i < $count && $i < $options['depth']; $i++) {
         $trace = array_merge(array('file' => '[internal]', 'line' => '??'), $backtrace[$i]);
         $function = '[main]';
         if (isset($backtrace[$i + 1])) {
             $next = $backtrace[$i + 1] + $traceDefault;
             $function = $next['function'];
             if (!empty($next['class'])) {
                 $function = $next['class'] . '::' . $function . '(';
                 if ($options['args'] && isset($next['args'])) {
                     $args = array_map(array('static', 'export'), $next['args']);
                     $function .= join(', ', $args);
                 }
                 $function .= ')';
             }
         }
         if ($options['closures'] && strpos($function, '{closure}') !== false) {
             $function = static::_closureDef($backtrace[$i], $function);
         }
         if (in_array($function, array('call_user_func_array', 'trigger_error'))) {
             continue;
         }
         $trace['functionRef'] = $function;
         if ($options['format'] === 'points' && $trace['file'] !== '[internal]') {
             $back[] = array('file' => $trace['file'], 'line' => $trace['line']);
         } elseif (is_string($options['format']) && $options['format'] !== 'array') {
             $back[] = String::insert($options['format'], array_map(function ($data) {
                 return is_object($data) ? get_class($data) : $data;
             }, $trace));
         } elseif (empty($options['format'])) {
             $back[] = $function . ' - ' . $trace['file'] . ', line ' . $trace['line'];
         } else {
             $back[] = $trace;
         }
         if (!empty($scope) && array_intersect_assoc($scope, $trace) == $scope) {
             if (!$options['includeScope']) {
                 $back = array_slice($back, 0, count($back) - 1);
             }
             break;
         }
     }
     if ($options['format'] === 'array' || $options['format'] === 'points') {
         return $back;
     }
     return join("\n", $back);
 }

 /**
  * Writes the message to the configured cache adapter.
  *
  * @param string $type
  * @param string $message
  * @return closure Function returning boolean `true` on successful write, `false` otherwise.
  */
 public function write($type, $message)
 {
     $config = $this->_config + $this->_classes;
     return function ($self, $params) use($config) {
         $params += array('timestamp' => strtotime('now'));
         $key = $config['key'];
         $key = is_callable($key) ? $key($params) : String::insert($key, $params);
         $cache = $config['cache'];
         return $cache::write($config['config'], $key, $params['message'], $config['expiry']);
     };
 }

 /**
  * Main method
  * @param  array  $menu    The menu description.
  * @param  array  $options Options.
  * @return string          The HTML buffer.
  */
 public function display(array $menu, array $options = array())
 {
     $options += static::$defaults;
     $menu = $this->_prepare($menu, $options);
     $out = String::insert($options['open'], $options);
     foreach ($menu as $item) {
         $out .= String::insert($options['content'], $item);
     }
     $out .= $options['close'];
     return $out;
 }