bmcclure/cakephp-menu-plugin

A CakePHP 2.0 plugin designed to help build menus in the controller and display them in the view

cakephp-menu-plugin's Issues

Only last children from menu renders

Ben, I have this Menu, loaded using a Model:

\app\Model\Menu.php (line 176)

array(
    (int) 77 => array(
        'title' => 'Musicas',
        'url' => array(
            'controller' => 'musicas',
            'action' => 'index'
        )
    ),
    (int) 78 => array(
        'title' => 'Desenvolvedor',
        'url' => 'javascript:void(0)',
        'children' => array(
            (int) 0 => array(
                'title' => 'Grupos de Usuários',
                'url' => array(
                    'controller' => 'grupos',
                    'action' => 'index'
                )
            ),
            (int) 1 => array(
                'title' => 'Grupos de Permissões',
                'url' => array(
                    'controller' => 'permissoes',
                    'action' => 'index'
                )
            ),
            (int) 2 => array(
                'title' => 'Usuários',
                'url' => array(
                    'controller' => 'usuarios',
                    'action' => 'index'
                )
            ),
            (int) 3 => array(
                'title' => 'Permissões',
                'url' => array(
                    'controller' => 'permissoes',
                    'action' => 'index'
                )
            ),
            (int) 4 => array(
                'title' => 'Menus',
                'url' => array(
                    'controller' => 'menus',
                    'action' => 'index'
                )
            )
        )
    )
)

The strange thing is when I tell the plugin to render my menu, only the last children is rendered:

(int) 4 => array(
                'title' => 'Menus',
                'url' => array(
                    'controller' => 'menus',
                    'action' => 'index'
                )
            )

Maybe I'm doing something wrong when populating the menu array, I don't know. But what I'm doing is just getting all the menu list from database and put them in an array.

Thanks.

w

Remove Kint references

Not an issue!

I just found some code that make reference to the helper Kint but it is not used in MenuRendererHelper, line 20:

var $helpers = array('Html', 'Kint.Kint');

Support 'parent' option for auto-generated menus

When auto-generating a menu, it should check for a 'parent' option being specified and place the menu under that parent instead.

How this should be done is yet to be determined. Simplest would be to simply pass a Menu object or a MenuItem object in for the 'parent' option, however when using MenuBuilder you might not actually have the underlying Menu or MenuItem.

Using the name of the menu to add it to is easy, but then defining which item under that to use might be difficult unless I create better ways of finding existing menu items in the stucture.

Maybe a 'hasChild($name) on Menu would work well enough. to be able to loop through a menu and drill down to a specific item.

We could then add getChild($name) to traverse the tree and return the correct MenuItem.

Plugin Menu could not be found

Strange...when I declare the helper MenuBuilder.MenuRenderer:

public $helpers = array('MenuBuilder.MenuRenderer');

I receive this error:

Plugin Menu could not be found.

Looks like something is trying to call a plugin named "Menu". Just dont know why.

Support 'alias' option for auto-generated menus

When generating menus with MenuBuilderComponent, it should check for an option 'alias' containing a keyed array. The keys should be an action (method) name, and the value should be the alias that should be displayed instead.

This should essentially be just like Mark Story's AclMenuComponent:

var $options = array(
    'alias' => array(
        'admin_index' => 'View all Posts',
    ),
);

Helper class MenuBuilderHelper could not be found.

I installed the plugin as described in the instructions, including renaming the plugin directory to "menu_builder." Added it to the $helpers array as MenuBuilder.MenuBuilder, and constructed the beforeFilter array pretty much as described in the instructions. Added it to my default layout as described, and I get fatal error: Error: An Internal Error Has Occurred. Helper class MenuBuilderHelper could not be found. The only helper class in the plugin that I can find is MenuRendererHelper. What do I need to do to make it work?

how to customized the menu for cakePHP 2.x

First of all thank for the plug in. You should update the documents because it will kill the newbie like me.

I manage to install it to my cakePHP 2.3 successfully; however, it show in vertical position whereas I want it as horizontal of the top of my page.
any idea?

could I use it with twitter boostrap or Jquery UI ?

Menu class conflicts with model class named Menu

As referenced in #5

The MenuLib library included with the plugin currently registers itself with Cake's autoloader to avoid Class Not Found errors.

This means any model class (or other class) with the same name as a class within MenuLib could potentially conflict (you could get an instance of a MenuLib class when you want a model class, for instance).

To resolve this, I'm going to try to implement namespaces within MenuLib, and always refer to MenuLib's classes using the namespace path.

Menu with ACL

Hi

This plugin looks really good. I am new to cake so please forgive me if this question is silly.

I have followed tutorial from cookbook and my acl is working now. my user is linked to group table with group_id as foreign key.
when i tried to use your plugin I couldn't figure out how to tell authField to look for group.name field and match it with permissions array key.

user table: id, username,password,group_id
group table: id,name

also normal aro, aco and aros_acos tables exists.

please help

Write tests!

Problem with ACL

Hi,

I was wondering if anyone has ACL Menu Component by Mark Story updated for cakephp 2.

I am sorry if this is not the place to ask about another plugin but I am out of options.

I tried to update the plugin myself but I am stuck at the following error:

http://imm.io/MK9J

http://imm.io/MK9W

http://imm.io/MKa7

Here is the modified code:

```php
<?php
/**
 * Menu Component
 *
 * Uses ACL to generate Menus.
 *
 * Copyright 2008, Mark Story.
 *
 * Licensed under The MIT License
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright 2008, Mark Story.
 * @link http://mark-story.com
 * @version 1.1
 * @author Mark Story <[email protected]>
 * @license http://www.opensource.org/licenses/mit-license.php The MIT License
 */
class MenuComponent extends Component {
/**
 * The Default Menu Parent for things that have no parent element defined
 * used a lot by menu items generated by controller folder scrapings
 *
 * @var string
 */
    public $defaultMenuParent = null;
/**
 * Set to false to disable the auto menu generation in startup()
 * Useful if you want your menus generated off of Aro's other than the user in the current session.
 *
 * @var boolean
 */
    public $autoLoad = true;
/**
 * Controller reference
 *
 * @var object
 */ 
    public $Controller = null;
/**
 * Components used by Menu
 *
 * @var array
 */
    public $components = array('Acl', 'Auth');

/**
 * Key for the caching
 *
 * @var string
 */
    public $cacheKey = 'menu_storage';

/**
 * Time to cache menus for.
 *
 * @var string  String compatible with strtotime.
 */
    public $cacheTime = '+1 day';
/**
 * cache config key
 *
 * @var string
 */
    public $cacheConfig = 'menu_component';
/**
 * Separator between controller and action name.
 *
 * @var string
 */
    public $aclSeparator = '/';

/**
 * The Node path to get to the controller listing
 *
 * @var string
 **/
    public $aclPath = 'controllers/';

/**
 * Array of Actions to exclude when making menus.
 * Per controller exclusions can be set with Controller::menuOptions
 *
 * @var array
 **/
    public $excludeActions = array('view', 'edit', 'delete', 'admin_edit', 'admin_delete', 'admin_edit', 'admin_view');

/**
 * Completed list of methods to not include in menus. Includes all of Controller's methods.
 *
 * @var array
 **/
    public $excludedMethods = array();
/**
 * The Completed menu for the current user.
 *
 * @var array
 */
    public $menu = array(); 

/**
 * Raw menus before formatting, either loaded from parsing controllers directory or loading Cache
 *
 * @var array
 */
    public $rawMenus = array();
/**
 * Internal Flag to check if new menus have been added to a cached menu set.  Indicates that new menu items
 * have been added and that menus need to be rebuilt.
 * 
 */
    protected $_rebuildMenus = false;

/**
 * initialize function
 *
 * Takes Settings declared in Controller and assigns them.
 *
 * @return bool
 **/
    public function initialize(Controller $controller) {
        if (!empty($settings)) {
            $this->_set($settings);
        }
        return true;
    }

/**
 * Startup Method
 *
 * Automatically makes menus for all a the controllers based on the current user.
 * If $this->autoLoad = false then you must manually loadCache(), 
 * contstructMenu() and writeCache().
 *
 * @param Object $Controller
 */
    public function startup(Controller $controller) {
        $this->Controller =& $Controller;

        Cache::config($this->cacheConfig, array('engine' => 'File', 'duration' => $this->cacheTime, 'prefix' => $this->cacheKey));

        //no active session, no menu can be generated
        if (!$this->Auth->user()) {
            return;
        }
        if ($this->autoLoad) {
            $this->loadCache();
            $this->constructMenu($this->Auth->user());
            $this->writeCache();
        }
    }

/**
 * Write the current Block Access data to a file.
 *
 * @return boolean on success of writing a file.
 */
    public function writeCache() {
        $data = array(
            'menus' => $this->rawMenus
        );
        if (Cache::write($this->cacheKey, $data, $this->cacheConfig)) {
            return true;
        }
        $this->log('Menu Component - Could not write Menu cache.');
        return false;
    }

/**
 * Load the Cached Permissions and restore them
 *
 * @return boolean true if cache was loaded.
 */
    public function loadCache() {
        if ($data = Cache::read($this->cacheKey, $this->cacheConfig)) {
            $this->rawMenus = $this->_mergeMenuCache($data['menus']);
            return true;
        }
        $this->_rebuildMenus = true;
        return false;
    }

/**
 * Clears the raw Menu Cache, this will in turn force
 * a menu rebuild for each ARO that needs a menu.
 *
 * @return boolean
 **/
    public function clearCache() {
        return Cache::delete($this->cacheKey, $this->cacheConfig);
    }

/**
 * Construct the menus From the Controllers in the Application.  This is an expensive
 * Process Timewise and is cached.
 *
 * @param string $aro  Aro Alias / identification array that a menu is needed for.
 */ 
    public function constructMenu($aro) {
        $aroKey = $aro;
        if (is_array($aro)) {
            $aroKey = key($aro) . $aro[key($aro)];
        }
        $cacheKey = $aroKey . '_' . $this->cacheKey;
        $completeMenu = Cache::read($cacheKey, $this->cacheConfig);
        if (!$completeMenu || $this->_rebuildMenus == true) {
            $this->generateRawMenus();

            $menu = array();
            $size = count($this->rawMenus);
            for ($i = 0; $i < $size; $i++) {
                $item = $this->rawMenus[$i];

                $aco = Inflector::underscore($item['url']['controller']);
                if (isset($item['url']['action'])) {
                    $aco = $this->aclPath . $aco . $this->aclSeparator . $item['url']['action'];
                }
                if ($this->Acl->check($aco, $aro)) {
                    if (!isset($menu[$item['id']])) {
                        $menu[$item['id']] = $this->rawMenus[$i];
                    }
                }
            }
            $completeMenu = $this->_formatMenu($menu);
            Cache::write($cacheKey, $completeMenu, $this->cacheConfig);
        }
        $this->menu = $completeMenu;
    }

/**
 * Generate Raw Menus from Controller in the Application
 * Loads a list of All controllers in the app/controllers, imports the class and gets a method
 * list.  Uses a common exclusion list to remove unwanted methods.  Each Controller can specify a 
 * menuOptions var which allows additional menu configuration.
 * 
 * Menu Options for Controllers:
 *      exclude => actions to exclude from the menu list
 *      parent => Parent link to add a controller / actions underneath
 *      alias => array of action => aliases Allows you to set friendly link names for actions
 *
 * @return void sets $this->rawMenus
 */ 
    public function generateRawMenus() {
        $Controllers = $this->getControllers();
        $cakeAdmin = Configure::read('Routing.admin');
        $this->createExclusions();

        //go through the controllers folder and make an array of every menu that could be used.
        foreach($Controllers as $Controller) {
            if ($Controller == 'App') {
                continue;
            }

            $ctrlName = $Controller;
            App::uses($ctrlName, 'Controller');
            $ctrlclass = $ctrlName;
            $methods = get_class_methods($ctrlclass);
            $classVars = get_class_vars($ctrlclass);

            $menuOptions = $this->setOptions($classVars);
            if ($menuOptions === false) {
                continue;
            }

            $methods = $this->filterMethods($methods, $menuOptions['exclude']);

            $ctrlCamel = Inflector::variable($ctrlName);
            $ctrlHuman = Inflector::humanize(Inflector::underscore($ctrlCamel));
            $methodList = array();
            $adminController = false;
            foreach ($methods as $action) {
                $camelAction = Inflector::variable($action);

                if (empty($menuOptions['alias']) || !isset($menuOptions['alias'][$action])) {
                    $human = Inflector::humanize(Inflector::underscore($action));
                } else {
                    $human = $menuOptions['alias'][$action];
                }
                $url = array(
                    'controller' => $ctrlCamel,
                    'action' => $action
                );
                if ($cakeAdmin) {
                    $url[$cakeAdmin] = false;
                }
                if (strpos($action, $cakeAdmin . '_') !== false && $cakeAdmin) {
                    $url[$cakeAdmin] = true;
                    $adminController = true;
                }

                $parent = $menuOptions['controllerButton'] ? $ctrlCamel : $menuOptions['parent'];
                $this->rawMenus[] = array(
                    'parent' => $parent,
                    'id' => $this->_createId($ctrlCamel, $action),
                    'title' => $human,
                    'url' => $url,
                    'weight' => 0,
                );
            }

            if ($menuOptions['controllerButton']) {
                //If an admin index exists use it.
                $action = $adminController ? $cakeAdmin . '_index' : 'index';
                $url = array(
                    'controller' => $ctrlCamel,
                    'action' => $action,
                    'admin' => $adminController,
                );
                $menuItem = array(
                    'parent' => $menuOptions['parent'],
                    'id' => $ctrlCamel,
                    'title' => $ctrlHuman,
                    'url' => $url,
                    'weight' => 0
                );
                $this->rawMenus[] = $menuItem;
            }
        }
    }

/**
 * Get the Controllers in the Application
 *
 * @access public
 * @return void
 */
    public function getControllers() {
        return App::objects('controller');
    }

/**
 * filter out methods based on $menuOptions.
 * Removes private actions as well.
 *
 * @param array $methods  Array of methods to prepare
 * @param array $remove Array of additional Methods to remove, normally options on the controller.
 * @return array
 **/
    public function filterMethods($methods, $remove = array()) {
        if (!empty($remove)) {
            $remove = array_map('strtolower', $remove);
        }
        $exclusions = array_merge($this->excludedMethods, $remove);
        foreach ($methods as $k => $method) {
            $method = strtolower($method);
            if (strpos($method, '_', 0) === 0) {
                unset($methods[$k]);
            }
            if (in_array($method, $exclusions)) {
                unset($methods[$k]);
            }
        }
        return array_values($methods);
    }

/**
 * Set the Options for the current Controller.
 *
 * @return mixed.  Array of options or false on total exclusion
 **/
    public function setOptions($controllerVars) {
        $cakeAdmin = Configure::read('Routing.admin');
        $menuOptions = isset($controllerVars['menuOptions']) ? $controllerVars['menuOptions'] : array();

        $exclude = array('view', 'edit', 'delete', $cakeAdmin . '_edit', 
            $cakeAdmin . '_delete', $cakeAdmin . '_edit', $cakeAdmin . '_view');

        $defaults = array(
            'exclude' => $exclude, 
            'alias' => array(), 
            'parent' => $this->defaultMenuParent, 
            'controllerButton' => true
        );
        $menuOptions = Set::merge($defaults, $menuOptions);
        if (in_array('*', (array)$menuOptions['exclude'])) {
            return false;
        }
        return $menuOptions;
    }

/**
 * Creates the Exclusions for generating menus.
 *
 * @return void
 **/
    public function createExclusions() {
        $methods = array_merge(get_class_methods('Controller'), $this->excludeActions);
        $this->excludedMethods = array_map('strtolower', $methods);
    }
/**
 * Add a Menu Item.
 * Allows manual Insertion into the menu system.
 * If Added after constructMenu()  It will not be shown
 *
 * @param string $parent
 * @param array $menu
 *      'Menu' Array
 *          'title' => name
 *          'url' => url array of menu, url strings are lame and won't work
 *          'key' => unique name of this menu for parenting purposes.
 *          'controller' => controller Name this action is from
 */
    public function addMenu($menu) {
        $defaults = array(
            'title' => null,
            'url' => null,
            'parent' => null,
            'id' => null,
            'weight' => 0,
        );
        $menu = array_merge($defaults, $menu);
        if (!$menu['id'] && isset($menu['url'])) {
            $menu['id'] = $this->_createId($menu['url']);
        }
        if (!$menu['title'] && isset($menu['url']['action'])) {
            $menu['title'] = Inflector::humanize($menu['url']['action']);
        }
        $this->rawMenus[] = $menu;
    }

/**
 * BeforeRender Callback.
 *
 */
    public function beforeRender(Controller $controller) {
        $this->Controller->set('menu', $this->menu);
    }

/**
 * Make a Unique Menu item key
 *
 * @param array $parts
 * @return string Unique key name
 */
    protected function _createId() {
        $parts = func_get_args();
        if (is_array($parts[0])) {
            $parts = $parts[0];
        }
        $key = Inflector::variable(implode('-', $parts));
        return $key;
    }

/**
 * Recursive function to construct Menu
 *
 * @param unknown_type $menu
 * @param unknown_type $parentId
 */
    protected function _formatMenu($menu) {
        $out = $idMap = array();
        foreach ($menu as $item) {
            $item['children'] = array();
            $id = $item['id'];
            $parentId = $item['parent'];
            if (isset($idMap[$id]['children'])) {
                $idMap[$id] = am($item, $idMap[$id]);
            } else {
                $idMap[$id] = am($item, array('children' => array()));
            }
            if ($parentId) {
                $idMap[$parentId]['children'][] =& $idMap[$id];
            } else {
                $out[] =& $idMap[$id];
            }
        }
        usort($out, array(&$this, '_sortMenu'));
        return $out;
    }

/**
 * Sort the menu before returning it. Used with usort()
 *
 * @return int
 **/
    protected function _sortMenu($one, $two) {
        if ($one['weight'] == $two['weight']) {
            return 1;
        }
        return ($one['weight'] < $two['weight']) ? -1 : 1;
    }
/**
 * Merge the Cached menus with the Menus added in Controller::beforeFilter to ensure they are unique.
 *
 * @param array $cachedMenus
 * @return array Merged Menus
 */
    protected function _mergeMenuCache($cachedMenus) {
        $cacheCount = sizeOf($cachedMenus);
        $currentCount = sizeOf($this->rawMenus);
        $tmp = array();
        for ($i = 0; $i < $currentCount; $i++) {
            $exist = false;
            $addedMenu = $this->rawMenus[$i];
            for ($j =0; $j < $cacheCount; $j++) {
                $cachedItem = $cachedMenus[$j];
                if ($addedMenu['id'] == $cachedItem['id']) {
                    $exist = true;
                    break;
                }
            }
            if ($exist) {
                continue;
            }
            $tmp[] = $addedMenu;
        }
        if (!empty($tmp)) {
            $this->_rebuildMenus = true;
        }
        return array_merge($cachedMenus, $tmp);
    }

}
?>```

Thank you in advance.

Support 'exclude' option for auto-generated menus

Just like the 'alias' option, when auto-generating a menu MenuBuilderComponent should check for an 'exclude' option and exclude any actions found in that array from being added to the menu.

It should work like Mark Story's AclMenuComponent:

var $menuOptions = array(
    'exclude' => array('secretStuff');
);
//Or
var $menuOptions = array(
    'exclude' => array('*');
);

Menu Icon

Ben, is it possible to add an option to add an icon for each menu item?

Something like:

// Define your menu
    $menu = array(
            'main-menu' => array(
                array(
                    'title' => 'Home',
                    'url' => array('controller' => 'pages', 'action' => 'home'),
                   'icon' => 'URL_TO_ICON'
                )
            ),
        ...

Update (or rewrite) readme file

unable to alter renderer settings from helper call

options passed as second param inside $this->MenuRenderer->render() call are not affecting renderer default settings i.e. i am unable to set menu classes and so on

Tutorial: How to install the CakePHP-Menu

The readme is too old to use them for installing this CakePHP-Menu.
After hours of reading threads in the internet and reading the classes to install this Plugin correctly, i got it to work.

For beginners it is hard to understand what things are to do...
Here a little tutorial:

1. Download the newest package: https://github.com/bmcclure/CakePHP-Menu-Plugin/archive/cake-2.0.zip
   ATTENTION: Not the old one which was linked in the readme!
2. Copy the whole folder "CakePHP-Menu-Plugin-cake-2.0" to your plugin directory (by default e.g. app/Plugin)
3. Rename the plugin folder to "Menu"
4. if you dont load all your plugins at once, you must load it in your bootstrap. write the following in your bootstrap (app/Config/bootstrap.php by default)

CakePlugin::load('Menu', array('bootstrap' => true));

1. go to your AppController (by default app/Controller/AppController.php) and extend your components-variable or init the components variable:

public $components = array('Menu.MenuBuilder');

So my components-array is now:

public $components = array('DebugKit.Toolbar', 'Session', 'Menu.MenuBuilder');

1. create a new function in your AppController for creating the menu array (like this array in the readme. this works) and add the view-helper at the beginning:

private function build_menu()
    {
        $this->helpers[] = 'Menu.MenuRenderer'; //Add the MenuHelper
                //Create the menu-Array
        $menus = array(
            array(
                'title' => 'User',
                'url' => array('controller' => 'users', 'action' => 'index'),
                'children' => array(
                    array(
                        'title' => 'User overview',
                        'url' => array('controller' => 'users', 'action' => 'index'),
                    ),
                    array(
                        'title' => 'New User',
                        'url' => array('controller' => 'users', 'action' => 'add'),
                    ),
                ),
            ),
            array(
                'title' => 'Roles',
                'url' => array('controller' => 'roles', 'action' => 'index'),
                'children' => array(
                    array(
                        'title' => 'Role overview',
                        'url' => array('controller' => 'roles', 'action' => 'index'),
                    ),
                    array(
                        'title' => 'New Role',
                        'url' => array('controller' => 'roles', 'action' => 'add'),
                    ),
                    array(
                        'title' => 'Show Role-Restrictions',
                        'url' => array('controller' => 'role_access_restrictions', 'action' => 'index'),
                    ),
                    array(
                        'title' => 'New Role-Restrictions',
                        'url' => array('controller' => 'role_access_restrictions', 'action' => 'add'),
                    ),

                ),
            ),
    );
    $this->MenuBuilder->setMenu('main-menu',$menus); //Now you set the name here! not in the array
    // For default settings name must be menus
//ATTENTION: default is now "menus", not "menu"
    $this->set('menus',$this->MenuBuilder->getMenu('main-menu')); //To have the menu in your View
    }

Use your new function in beforeFilter:

    public function beforeFilter()
    {
        $this->build_menu();
    }

1. Render the menu in your view (e.g. default.ctp)

<?php echo $this->MenuRenderer->render('main-menu'); ?>

Ready! now your menu were built ;-)

Consider removing MenuItem classes

MenuItem might be overkill.

The Menu class serves a purpose in referencing a MenuRenderer, containing settings and meta information about a menu, and containing the menu items themselves.

The MenuItem classes, however, really only contain properties about a menu item and a reference to a MenuItemRenderer.

Perhaps it would be better for application performance if a MenuItem was simply an array of properties (containing at least a 'title' and 'url' property, an option 'renderer' property, and potentially others depending on the renderer you're using.).

The class doesn't do anything other than create an inheritance tree and allow MenuItemRenderers to only render certain types of MenuItems. This can be done just as easily with a check for a required property in the array.

But would the performance benefits of eliminating that entire class tree outweigh the potential clarity and extensibility of keeping them as classes serving a specific purpose instead of generic array items?