/**
* loadAsset
* Load CSS & JS
* @param type $widget
* @param type $option
*/
public function loadAsset($widget = 'jqueryui', $option = array('inline' => false))
{
$asset_path = $this->settings['asset_path'];
$assets = Set::normalize($this->settings['runtimes'], false);
// gears,html5,flash,browserplus,silverlight,html4
echo $this->Html->script($asset_path . 'plupload', array('inline' => $option['inline']));
if (count($assets) > 2) {
echo $this->Html->script($asset_path . "plupload.full.js", array('inline' => $option['inline']));
} else {
foreach ($assets as $asset) {
echo $this->Html->script($asset_path . "plupload.{$asset}", array('inline' => $option['inline']));
}
}
if (!empty($this->settings['locale'])) {
echo $this->Html->script($asset_path . 'i18n/' . $this->settings['locale'], array('inline' => $option['inline']));
}
switch ($widget) {
case 'jquery':
echo $this->Html->script($asset_path . 'jquery.plupload.queue/jquery.plupload.queue', array('inline' => false));
echo $this->Html->css($asset_path . 'jquery.plupload.queue/css/jquery.plupload.queue', null, array('inline' => false));
break;
case 'jqueryui':
default:
echo $this->Html->script($asset_path . 'jquery.ui.plupload/jquery.ui.plupload', array('inline' => false));
echo $this->Html->css($asset_path . 'jquery.ui.plupload/css/jquery.ui.plupload', null, array('inline' => false));
break;
}
}
public function cakeArrayToArray($data, $options = array())
{
$options += array('fields' => array(), 'models' => array());
$options['fields'] = Set::normalize($options['fields'], false);
$options['models'] = Set::normalize($options['models'], false);
$options += array('defaultModel' => count($options['models']) == 1 ? $options['models'][0] : null);
$firstRow = true;
$array = array();
foreach ($data as $item) {
foreach ($item as $model => $fields) {
if ($options['models'] && !in_array($model, $options['models'])) {
continue;
}
foreach ($fields as $field => $value) {
if ($options['fields'] && !in_array($field, $options['fields']) && !in_array("{$model}.{$field}", $options['fields'])) {
continue;
}
if ($firstRow) {
if ($model == $options['defaultModel']) {
$array[0][] = $field;
} else {
$array[0][] = "{$model}.{$field}";
}
}
$row[] = $value;
}
$array[] = $row;
}
$firstRow = false;
}
return $array;
}
protected function _setSlugOptions()
{
foreach (Set::normalize($this->options['slugs']) as $slug => $options) {
$defaultBySlug = array('display' => $slug);
$this->_slugOptions[$slug] = Set::merge(array_intersect_key($this->options, array_flip(array('model', 'urlencode'))), $defaultBySlug, self::$defaultSlugOptions, $options);
}
}
/**
* Loads a Component
*
* @param string $component Name of component to load
* @return Object loaded component
**/
public function loadComponent($settings = array())
{
if (!isset($this->Controller)) {
$this->loadController();
}
$component = new $this->componentClass(null);
if (method_exists($component, 'initialize')) {
$component->initialize($this->Controller, $settings);
}
if (isset($component->components) && is_array($component->components)) {
$components = (array) Set::normalize($component->components);
foreach (array_keys($components) as $c) {
$this->Controller->Component->_loadComponents($component, $c);
}
foreach ($components as $c => $config) {
list($plugin, $c) = pluginSplit($c, true, null);
if (method_exists($component->{$c}, 'initialize')) {
$component->{$c}->initialize($this->Controller, $config);
}
if (method_exists($component->{$c}, 'startup')) {
$component->{$c}->startup($this->Controller);
}
}
}
$this->{$this->componentName} = $this->Controller->{$this->componentName} = $component;
return $this->{$this->componentName};
}
function parse($html = null, $blockName = 'document', $blockParams = null)
{
if (empty($html)) {
return;
}
$images = Set::normalize($html, false);
foreach ($images as &$image) {
if (!strpos($image, '://') && $image[0] != '/') {
$image = "img/{$image}";
}
$image = $this->_getHelper('SlHtml')->webroot($image);
SlConfigure::append("Asset.js.ready", "\$.preloadImages({$images})");
}
SlConfigure::write('Asset.js.footer.imagePreloader.after', <<<end
jQuery.preLoadImagesCache = [];
// Arguments are image paths relative to the current page.
jQuery.preLoadImages = function() {
var args_len = arguments.length;
for (var i = args_len; i--;) {
var cacheImage = document.createElement('img');
cacheImage.src = arguments[i];
jQuery.preLoadImagesCache.push(cacheImage);
}
}
end
);
}
function _findJoin(&$Model, $dummy, $state, $query, $results = array())
{
if ($state == 'after') {
return $results;
}
if (!isset($query[$this->optionName])) {
return $query;
}
$tojoin = Set::normalize($query[$this->optionName]);
$joins = isset($query['joins']) ? $query['joins'] : array();
foreach ($tojoin as $alias => $options) {
// Model::__associations is private property
foreach ($this->associations as $association) {
if (isset($Model->{$association}[$alias])) {
$join = $this->generateJoins($Model, $alias, $Model->{$association}[$alias], $association, $options);
if (!empty($join)) {
$joins = Set::merge($joins, $join);
$Model->unbindModel(array($association => array($alias)));
}
}
}
}
$query['joins'] = $joins;
return $query;
}
function beforeFind(&$Model, $query = array())
{
extract($this->settings);
if (!isset($query['virtualFields'])) {
return true;
}
$virtualFields = Set::normalize($query['virtualFields']);
unset($query['virtualFields']);
$blackList = array();
foreach ($virtualFields as $key => $sql) {
if ($sql !== false && empty($sql) || $sql === true) {
if (isset($Model->{$collectionName}[$key])) {
$virtualFields[$key] = $Model->{$collectionName}[$key];
} else {
unset($virtualFields[$key]);
}
} else {
$blackList[] = $key;
unset($virtualFields[$key]);
}
}
if (!empty($virtualFields) || !empty($blackList)) {
$this->__virtualFieldsBackup[$Model->alias] = $Model->virtualFields;
$Model->virtualFields = array_merge($Model->virtualFields, $virtualFields);
if (!empty($blackList)) {
foreach ($blackList as $key) {
if (isset($Model->virtualFields[$key])) {
unset($Model->virtualFields[$key]);
}
}
}
}
return $query;
}
function mergeVars($admin, $configuration)
{
if (empty($configuration)) {
$configuration = array($this->defaults);
}
$schema = $admin->modelObj->schema();
foreach ($configuration as $i => $config) {
foreach ($this->defaults as $key => $value) {
if (!isset($config[$key])) {
$configuration[$i][$key] = $value;
}
}
$fields = array();
if (empty($configuration[$i]['fields']) || in_array('*', (array) $configuration[$i]['fields'])) {
// $fields is all fields
foreach (array_keys($schema) as $field) {
$fields[$field] = array('label' => Inflector::humanize($field));
}
}
if (!empty($configuration[$i]['fields'])) {
$configuration[$i]['fields'] = Set::normalize($configuration[$i]['fields']);
foreach ((array) $configuration[$i]['fields'] as $field => $config) {
if ($field === '*') {
continue;
}
if (empty($configuration[$i])) {
$config = array();
} else {
if (is_string($config)) {
$config = array('label' => $config);
}
}
if (empty($config['label'])) {
$config['label'] = Inflector::humanize($field);
}
$fields[$field] = $config;
}
}
if (!empty($configuration[$i]['exclude'])) {
foreach ($configuration[$i]['exclude'] as $field) {
if (in_array($field, array_keys($fields))) {
$fields = array_diff_key($fields, array($field => $field));
}
}
}
if (!empty($configuration[$i]['hidden'])) {
foreach ((array) $configuration[$i]['hidden'] as $field) {
if (in_array($field, array_keys($fields))) {
$fields[$field]['type'] = 'hidden';
}
}
}
$configuration[$i]['fields'] = $fields;
$configuration[$i]['classes'] = (string) $configuration[$i]['classes'];
$configuration[$i]['description'] = (string) $configuration[$i]['description'];
}
return $configuration;
}
public function append($name, $settings = array())
{
if (is_array($name)) {
foreach (Set::normalize($name) as $n => $settings) {
$this->__set($n, $settings);
}
return true;
}
return $this->__set($name, $settings);
}
public function admin_index($activeSection = null)
{
$this->set('sections', $sections = SlConfigure::read2("Config.sections"));
foreach ($sections as $section => $settings) {
if (!SlAuth::isAuthorized('config' . Inflector::camelize($section))) {
unset($sections[$i]);
}
}
if (isset($this->data['_section'])) {
$activeSection = $this->data['_section'];
}
if (empty($activeSection) || !isset($sections[$activeSection])) {
$activeSection = reset(array_keys($sections));
}
$settings = $this->_getSettings($activeSection);
$this->set('title', __t(SlConfigure::read2("Config.sections.{$activeSection}")));
if ($this->data) {
$locales = SlConfigure::read('I18n.locales');
foreach ($settings as $name => &$setting) {
if (is_int($name)) {
$name = "setting_{$name}";
}
if ($setting['collection'] == 'user') {
$setting['collection'] = 'User' . SlAuth::user('id');
}
if (empty($setting['translate'])) {
if (isset($this->data[$name])) {
$value = $this->data[$name];
if (isset($setting['type']) && $setting['type'] == 'json') {
$value = json_decode($value, true);
} elseif (isset($setting['type']) && $setting['type'] == 'array') {
$value = Set::normalize($value, false);
}
SlConfigure::write($setting['name'], $value, true, $setting['collection']);
}
} else {
foreach ($locales as $locale) {
if (isset($this->data["{$name}_{$locale}"])) {
$value = $this->data["{$name}_{$locale}"];
if (isset($setting['type']) && $setting['type'] == 'json') {
$value = json_decode($value, true);
} elseif (isset($setting['type']) && $setting['type'] == 'array') {
$value = Set::normalize($value, false);
}
SlConfigure::write($setting['name'], $value, true, "{$setting['collection']}.{$locale}");
}
}
}
}
$settings = $this->_getSettings($activeSection);
$this->Session->setFlash(__t('Configuration saved'), array('class' => 'success'));
}
$this->data['_section'] = $activeSection;
$this->set('settings', $settings);
}
function mergeVars($admin, $configuration)
{
if (empty($configuration)) {
return array($this->defaults);
}
$modelObj = ClassRegistry::init(array('class' => $admin->modelName, 'table' => $admin->useTable, 'ds' => $admin->useDbConfig));
$schema = $modelObj->schema();
foreach ($configuration as $i => $config) {
foreach ($this->defaults as $key => $value) {
if (!isset($config[$key])) {
$configuration[$i][$key] = $value;
}
}
$fields = array();
if (empty($configuration[$i]['fields']) || in_array('*', (array) $configuration[$i]['fields'])) {
// $fields is all fields
foreach (array_keys($schema) as $field) {
$fields[$field] = array();
}
} else {
$configuration[$i]['fields'] = Set::normalize($configuration[$i]['fields']);
foreach ((array) $configuration[$i]['fields'] as $field => $config) {
if (empty($configuration[$i])) {
$config = array();
} else {
if (is_string($config)) {
$config = array('label' => $config);
}
}
if ($field !== '*') {
$fields[$field] = $config;
}
}
}
if (!empty($configuration[$i]['exclude'])) {
foreach ($configuration[$i]['exclude'] as $field) {
if (in_array($field, array_keys($fields))) {
$fields = array_diff_key($fields, array($field => $field));
}
}
}
if (!empty($configuration[$i]['hidden'])) {
foreach ((array) $configuration[$i]['hidden'] as $field) {
if (in_array($field, array_keys($fields))) {
$fields[$field]['type'] = 'hidden';
}
}
}
$configuration[$i]['fields'] = $fields;
$configuration[$i]['classes'] = (string) $configuration[$i]['classes'];
$configuration[$i]['description'] = (string) $configuration[$i]['description'];
}
return $configuration;
}
/**
* Save tag and tagged models
*
* @param object $model
*/
function afterSave(&$model)
{
if (!isset($model->data[$model->alias]['tags'])) {
return;
}
$tagged_conditions = array('model' => $model->alias, 'model_id' => $model->id);
$this->Tagged->deleteAll($tagged_conditions, false, true);
$tags = Set::normalize($model->data[$model->alias]['tags'], false);
$tags = array_unique($tags);
foreach ($tags as $tag) {
$this->Tag->saveTag($tag, $tagged_conditions);
}
}
function _parseTrueToDefault($config)
{
$_this =& CaptchaConfig::getInstance();
$trueToDefault = Set::normalize($_this->trueToDefault);
foreach ($trueToDefault as $path => $options) {
if (Set::extract($path, $config) === true) {
if (empty($options)) {
$options = Set::extract($path, $_this->defaultConfig);
}
$config = Set::insert($config, $path, $options);
}
}
return $config;
}
function setup(&$Model, $settings = array())
{
if (empty($settings['fieldsOpt'])) {
$settings['fieldsOpt'] = array();
}
if (!empty($settings['fields'])) {
$settings['fieldsOpt'] = set::merge($settings['fieldsOpt'], array_filter(Set::normalize($settings['fields'])));
$settings['fields'] = array_keys(Set::normalize($settings['fields']));
}
if (empty($this->settings[$Model->alias])) {
$this->settings[$Model->alias] = $this->defSettings;
}
$this->settings[$Model->alias] = set::merge($this->settings[$Model->alias], $settings);
}
function loadComponent($componentName, $config = null, $parent = null)
{
$component = null;
$pathing = $this->componentPathing($componentName);
$created = false;
if (!isset($this->controller->Component->_loaded[$pathing['name']])) {
if (!class_exists($pathing['className'])) {
if (is_null($pathing['plugin']) || !App::import('Component', $pathing['fullName'])) {
if (!App::import('Component', $pathing['name'])) {
$this->cakeError('missingComponentFile', array(array('className' => $this->controller->name, 'component' => $pathing['name'], 'file' => Inflector::underscore($pathing['name']) . '.php', 'base' => '', 'code' => 500)));
return false;
}
}
if (!class_exists($pathing['className'])) {
$this->cakeError('missingComponentClass', array(array('className' => $this->controller->name, 'component' => $pathing['name'], 'file' => Inflector::underscore($pathing['name']) . '.php', 'base' => '', 'code' => 500)));
return false;
}
}
$component =& new $pathing['className']();
$created = true;
$component->enabled = true;
$this->controller->Component->_loaded[$pathing['name']] = $component;
} else {
$component =& $this->controller->Component->_loaded[$pathing['name']];
}
if (!empty($config)) {
if (isset($this->controller->Component->__settings[$pathing['name']])) {
$this->controller->Component->__settings[$pathing['name']] = array_merge($this->controller->Component->__settings[$pathing['name']], $config);
} else {
$this->controller->Component->__settings[$pathing['name']] = $config;
}
}
if (!empty($parent)) {
$parent->{$pathing['name']} = $component;
}
if (!empty($component->components)) {
$normal = Set::normalize($component->components);
foreach ((array) $normal as $subcomponent => $config) {
$this->loadComponent($subcomponent, $config, $component);
}
}
if ($created && method_exists($component, 'initialize') && $component->enabled === true) {
$settings = array();
if (isset($this->controller->Component->__settings[$pathing['name']])) {
$settings = $this->controller->Component->__settings[$pathing['name']];
}
$component->initialize($this->controller, $settings);
}
return $component;
}
function loadComponents($components, $startupDefault = true)
{
foreach ($components as $from => $alias) {
list($to, $settings) = each(Set::normalize($alias));
if (empty($settings)) {
$settings = array();
}
$startup = $startupDefault;
if (!$this->__primary && isset($settings['startup'])) {
$startup = $settings['startup'];
unset($settings['startup']);
}
$this->_loadComponent($from, $to, $settings, $startup);
}
}
function _reset()
{
$this->initialize(new MockTwitterTestController(), array('datasource' => 'test_twitter'));
$this->DataSource->reset();
// -- init components
$this->components = Set::normalize($this->components);
foreach ($this->components as $Component => $config) {
if (empty($config)) {
$config = array();
}
App::import('Component', $Component);
$this->{$Component} = ClassRegistry::init($Component . 'Component', 'Component');
$this->{$Component}->initialize($this->controller, $config);
}
}
function _replace($from, $alias)
{
list($to, $settings) = each(Set::normalize((array) $alias));
$loadedHelpers = array();
$this->view->_loadHelpers($loadedHelpers, array($to => $settings));
list($plugin, $to) = pluginSplit($to);
if (!isset($loadedHelpers[$to])) {
return false;
}
$loaded =& $loadedHelpers[$to];
list($plugin, $from) = pluginSplit($from);
$key = Inflector::variable($from);
$from = Inflector::classify($from);
$this->view->loaded[$key] = $loaded;
$this->view->{$from} =& $loaded;
return true;
}
function _reset($sets = null, $unsets = null)
{
unset($this->Controller);
$this->Controller = new AliasComponentTestController();
if ($unsets !== null) {
if ($unsets === true) {
$this->Controller->components = array();
} else {
$components = Set::normalize($this->Controller->components);
$this->Controller->components = Set::diff($components, array_flip((array) $unsets));
}
}
if ($sets !== null) {
$this->Controller->components = Set::merge($this->Controller->components, $sets);
}
$this->Controller->constructClasses();
$this->Controller->Component->initialize($this->Controller);
$this->Controller->beforeFilter();
}
function prepareJoins(&$Model, $tojoin)
{
$tojoin = Set::normalize($tojoin);
$cacheKey = sha1($Model->alias . serialize($tojoin));
$isCached = false;
if (isset($this->__cacheJoins[$cacheKey])) {
list($joins, $unbinds) = $this->__cacheJoins[$cacheKey];
$isCached = true;
} else {
$joins = array();
$unbinds = array();
foreach ($tojoin as $alias => $options) {
foreach ($this->associations as $association) {
if (isset($Model->{$association}[$alias])) {
$options = Set::merge($this->defaultOptions, $options);
$additionals = $options;
unset($additionals['type']);
unset($additionals['unbind']);
if (!empty($additionals)) {
$joins = array_merge($joins, $this->prepareJoins($Model->{$alias}, $additionals));
}
$join = $this->__joinsOptions($Model, $alias, $Model->{$association}[$alias], $association, $options);
if (!empty($join)) {
$joins = array_merge($joins, $join);
if ($options['unbind']) {
$unbinds[$association][] = $alias;
// $Model->unbindModel(array($association => array($alias)));
}
}
}
}
}
$joins = array_reverse($joins);
}
if (!empty($unbinds)) {
$Model->unbindModel($unbinds);
}
if (!$isCached) {
$this->__cacheJoins[$cacheKey] = array($joins, $unbinds);
}
return $joins;
}
public function configure($settings)
{
extract((array) $settings);
if (isset($disable)) {
$this->disable($disable);
}
if (isset($disableMethods)) {
foreach (Set::normalize($disableMethods) as $method => $callback) {
$this->disableMethod($method, $callback);
}
}
if (isset($enable)) {
$this->enable($enable);
}
if (isset($enableMethods)) {
foreach (Set::normalize($enableMethods) as $method => $callback) {
$this->enableMethod($method, $callback);
}
}
}
/**
*
* @param AppModel $model
* @param array $query
*/
function beforeFind(&$model, $query = array())
{
if (isset($query['virtualFields'])) {
$query['virtualFields'] = Set::normalize($query['virtualFields']);
foreach ($query['virtualFields'] as $key => $sql) {
if (empty($sql)) {
if (isset($model->virtualFieldCollection[$key])) {
$query['virtualFields'][$key] = $model->virtualFieldCollection[$key];
} else {
unset($query['virtualFields'][$key]);
}
}
}
}
if (!empty($query['virtualFields'])) {
$this->__cache[$model->alias] = $model->virtualFields;
$model->virtualFields = am($model->virtualFields, $query['virtualFields']);
}
return $query;
}
/**
* Creates all parameters on configuration using defaults, if not set.
* The configuration is stored back in the Configure class.
*
* @access public
* @return boolean Return true if succefully nomalized, false, if not.
*/
static function normalizeConfig()
{
$config = Configure::read('ContentStream');
if (Configure::read() && (!is_array($config['streams']) || Set::numeric(array_keys($config['streams'])))) {
return !trigger_error('CsConfigurator::normalizeConfig - ContentStream.streams must be a array indexed by type of content stream.');
}
$config['streams'] = Set::normalize($config['streams']);
foreach ($config['streams'] as $type => &$stream) {
if (!isset($stream['model'])) {
$stream['model'] = Inflector::camelize($type) . '.' . Inflector::classify($type);
}
if (!isset($stream['controller'])) {
$stream['controller'] = Inflector::pluralize($type);
}
if (!isset($stream['title'])) {
$stream['title'] = Inflector::humanize($type);
}
}
Configure::write('ContentStream', $config);
return self::$nomalized = true;
}
function startup(&$controller)
{
if (empty($this->settings['models']) && !empty($controller->modelClass)) {
$this->settings['models'] = array($controller->modelClass => array());
} elseif (!is_array($this->settings['models'])) {
$this->settings['models'] = array($this->settings['models'] => array());
} else {
$this->settings['models'] = Set::normalize($this->settings['models']);
}
$this->controller = $controller;
$this->CustomFilter = ClassRegistry::init('CustomFilter.CustomFilter');
$this->settings['currentFilters'] = $filterIds = $this->getCurentFilterIds();
if (in_array($controller->params['action'], $this->settings['actions'])) {
$controller->paginate = $this->applyFilters($controller->paginate, 'all', $filterIds);
$controller->helpers['CustomFilter.CustomFilter'] = array();
foreach ($this->settings['models'] as $alias => &$opt) {
if ($this->settings['autoLock']) {
$this->lockFilterSelection($alias, $filterIds);
}
if (!empty($controller->{$alias})) {
$controller->{$alias}->Behaviors->attach('CustomFilter.CustomFiltered', $opt);
}
$raw = $this->findActiveFilters($alias, $this->controller->user, $filterIds);
//debug($raw);
$opt['listData'] = array();
foreach ($raw as $filter) {
if (!empty($filter['MyCustomFilter'])) {
$filter['CustomFilter'] = array_merge($filter['CustomFilter'], $filter['MyCustomFilter']);
}
$opt['listData'][$filter['CustomFilterGroup']['id']]['CustomFilter'][$filter['CustomFilter']['id']] =& $filter['CustomFilter'];
$opt['listData'][$filter['CustomFilterGroup']['id']]['CustomFilterGroup'] = $filter['CustomFilterGroup'];
if (in_array($filter['CustomFilter']['id'], $filterIds)) {
$opt['current'][$filter['CustomFilter']['id']] =& $filter;
$opt['listData'][$filter['CustomFilterGroup']['id']]['CustomFilter'][$filter['CustomFilter']['id']]['current'] = 1;
}
}
}
$controller->params['CustomFilter'] = $this->settings;
}
}
function unserialize(&$Model, $results = null)
{
if (is_null($results)) {
$results =& $Model->data;
}
if (isset($Model->serializeFields)) {
$serializeFields = $Model->serializeFields;
if (!$serializeFields) {
$serializeFields = array();
} else {
if (!is_array($serializeFields) && $serializeFields) {
$serializeFields = array($serializeFields);
}
}
if (isset($results[$Model->alias])) {
$res =& $results[$Model->alias];
} else {
$res =& $results;
}
if (!isset($res[0])) {
$old_res =& $res;
unset($res);
$res = array(&$old_res);
}
foreach (Set::normalize($serializeFields) as $field => $opt) {
foreach ($res as &$r) {
if (isset($r[$Model->alias])) {
$r =& $r[$Model->alias];
}
if (isset($r[$field]) && !empty($r[$field])) {
$r[$field] = $this->unserializeFunct($Model, $r[$field]);
}
}
}
}
return $results;
}
/**
* test normalizing arrays
*
* @return void
*/
public function testNormalizeArrays()
{
$result = Set::normalize(array('one', 'two', 'three'));
$expected = array('one' => NULL, 'two' => NULL, 'three' => NULL);
$this->assertEquals($expected, $result);
$result = Set::normalize(array('one', 'two', 'three'), FALSE);
$expected = array('one', 'two', 'three');
$this->assertEquals($expected, $result);
$result = Set::normalize(array('one' => 1, 'two' => 2, 'three' => 3, 'four'), FALSE);
$expected = array('one' => 1, 'two' => 2, 'three' => 3, 'four' => NULL);
$this->assertEquals($expected, $result);
$result = Set::normalize(array('one' => 1, 'two' => 2, 'three' => 3, 'four'));
$expected = array('one' => 1, 'two' => 2, 'three' => 3, 'four' => NULL);
$this->assertEquals($expected, $result);
$result = Set::normalize(array('one' => array('a', 'b', 'c' => 'cee'), 'two' => 2, 'three'));
$expected = array('one' => array('a', 'b', 'c' => 'cee'), 'two' => 2, 'three' => NULL);
$this->assertEquals($expected, $result);
}
/**
* testMergeVars method
*
* @access public
* @return void
*/
function testMergeVars()
{
if ($this->skipIf(defined('APP_CONTROLLER_EXISTS'), '%s Need a non-existent AppController')) {
return;
}
$TestController =& new TestController();
$TestController->constructClasses();
$testVars = get_class_vars('TestController');
$appVars = get_class_vars('AppController');
$components = is_array($appVars['components']) ? array_merge($appVars['components'], $testVars['components']) : $testVars['components'];
if (!in_array('Session', $components)) {
$components[] = 'Session';
}
$helpers = is_array($appVars['helpers']) ? array_merge($appVars['helpers'], $testVars['helpers']) : $testVars['helpers'];
$uses = is_array($appVars['uses']) ? array_merge($appVars['uses'], $testVars['uses']) : $testVars['uses'];
$this->assertEqual(count(array_diff($TestController->helpers, $helpers)), 0);
$this->assertEqual(count(array_diff($TestController->uses, $uses)), 0);
$this->assertEqual(count(array_diff_assoc(Set::normalize($TestController->components), Set::normalize($components))), 0);
$expected = array('ControllerComment', 'ControllerAlias', 'ControllerPost');
$this->assertEqual($expected, $TestController->uses, '$uses was merged incorrectly, AppController models should be last.');
$TestController =& new AnotherTestController();
$TestController->constructClasses();
$appVars = get_class_vars('AppController');
$testVars = get_class_vars('AnotherTestController');
$this->assertTrue(in_array('ControllerPost', $appVars['uses']));
$this->assertNull($testVars['uses']);
$this->assertFalse(isset($TestController->ControllerPost));
$TestController =& new ControllerCommentsController();
$TestController->constructClasses();
$appVars = get_class_vars('AppController');
$testVars = get_class_vars('ControllerCommentsController');
$this->assertTrue(in_array('ControllerPost', $appVars['uses']));
$this->assertEqual(array('ControllerPost'), $testVars['uses']);
$this->assertTrue(isset($TestController->ControllerPost));
$this->assertTrue(isset($TestController->ControllerComment));
}
/**
* Loads components used by this component.
*
* @param object $object
* Object with a Components array
* @param object $parent
* the parent of the current object
* @return void
* @access protected
*/
function _loadComponents(&$object, $parent = null)
{
$base = $this->__controllerVars['base'];
$normal = Set::normalize($object->components);
foreach ((array) $normal as $component => $config) {
$plugin = isset($this->__controllerVars['plugin']) ? $this->__controllerVars['plugin'] . '.' : null;
list($plugin, $component) = pluginSplit($component, true, $plugin);
$componentCn = $component . 'Component';
if (!class_exists($componentCn)) {
if (is_null($plugin) || !App::import('Component', $plugin . $component)) {
if (!App::import('Component', $component)) {
$this->cakeError('missingComponentFile', array(array('className' => $this->__controllerVars['name'], 'component' => $component, 'file' => Inflector::underscore($component) . '.php', 'base' => $base, 'code' => 500)));
return false;
}
}
if (!class_exists($componentCn)) {
$this->cakeError('missingComponentClass', array(array('className' => $this->__controllerVars['name'], 'component' => $component, 'file' => Inflector::underscore($component) . '.php', 'base' => $base, 'code' => 500)));
return false;
}
}
if ($parent === null) {
$this->_primary[] = $component;
}
if (isset($this->_loaded[$component])) {
$object->{$component} =& $this->_loaded[$component];
if (!empty($config) && isset($this->__settings[$component])) {
$this->__settings[$component] = array_merge($this->__settings[$component], $config);
} elseif (!empty($config)) {
$this->__settings[$component] = $config;
}
} else {
if ($componentCn === 'SessionComponent') {
$object->{$component} =& new $componentCn($base);
} else {
if (PHP5) {
$object->{$component} = new $componentCn();
} else {
$object->{$component} =& new $componentCn();
}
}
$object->{$component}->enabled = true;
$this->_loaded[$component] =& $object->{$component};
if (!empty($config)) {
$this->__settings[$component] = $config;
}
if (isset($object->{$component}->components) && is_array($object->{$component}->components) && !isset($object->{$component}->{$parent})) {
$this->_loadComponents($object->{$component}, $component);
}
}
}
}
/**
* Normalizes a string or array list.
*
* @param mixed $list List to normalize
* @param boolean $assoc If true, $list will be converted to an associative array
* @param string $sep If $list is a string, it will be split into an array with $sep
* @param boolean $trim If true, separated strings will be trimmed
* @return array
* @access public
*/
function normalize($list, $assoc = true, $sep = ',', $trim = true)
{
if (is_string($list)) {
$list = explode($sep, $list);
if ($trim) {
$list = array_map('trim', $list);
}
if ($assoc) {
return Set::normalize($list);
}
} elseif (is_array($list)) {
$keys = array_keys($list);
$count = count($keys);
$numeric = true;
if (!$assoc) {
for ($i = 0; $i < $count; $i++) {
if (!is_int($keys[$i])) {
$numeric = false;
break;
}
}
}
if (!$numeric || $assoc) {
$newList = array();
for ($i = 0; $i < $count; $i++) {
if (is_int($keys[$i])) {
$newList[$list[$keys[$i]]] = null;
} else {
$newList[$keys[$i]] = $list[$keys[$i]];
}
}
$list = $newList;
}
}
return $list;
}
/**
* Return a value from an array list if the key exists.
*
* If a comma separated $list is passed arrays are numeric with the key of the first being 0
* $list = 'no, yes' would translate to $list = array(0 => 'no', 1 => 'yes');
*
* If an array is used, keys can be strings example: array('no' => 0, 'yes' => 1);
*
* $list defaults to 0 = no 1 = yes if param is not passed
*
* @param array $select Key in $list to return
* @param array|string $list can be an array or a comma-separated list.
* @return string the value of the array key or null if no match
* @link http://book.cakephp.org/2.0/en/core-utility-libraries/set.html#Set::enum
*/
public static function enum($select, $list = null)
{
if (empty($list)) {
$list = array('no', 'yes');
}
$return = null;
$list = Set::normalize($list, false);
if (array_key_exists($select, $list)) {
$return = $list[$select];
}
return $return;
}
