Code cleaning, test completing, added the icon_class feature

Author: MiltonLn

.coveragerc

@@ -0,0 +1,5 @@
+[run]
+source = menu_generator
+omit =
+    */tests/*
+    */apps.py

menu_generator/defaults.py

@@ -1,5 +1,3 @@
-from django.conf import settings
-
 MENU_NOT_FOUND = [
     {
         "name": "MENU NOT FOUND",

menu_generator/menu.py

@@ -1,11 +1,8 @@
 import copy
-
-
-from django.core.urlresolvers import reverse
-from django.core.urlresolvers import NoReverseMatch
 from django.core.exceptions import ImproperlyConfigured
+from django.urls import reverse, NoReverseMatch
 
-from . import utils as util
+from .utils import get_callable
 
 
 class MenuBase(object):
@@ -19,14 +16,15 @@ def __init__(self):
     def save_user_state(self, request):
         """
         Given a request object, store the current user attributes
+        :param request: HttpRequest
         """
         self.request = request
         self.path = request.path
 
-    def is_validated(self, item_dict):
+    def _is_validated(self, item_dict):
         """
-        Given a menu item dictionary, it returns true if menu item should be only shown
-        to users if a set validators are true. (e.g. show if user is remember of admin group)
+        Given a menu item dictionary, it returns true if the user passes all the validator's conditions, it means,
+        if the user passes all the conditions, the user can see the menu
         """
         validators = item_dict.get('validators')
         if not validators:
@@ -35,106 +33,104 @@ def is_validated(self, item_dict):
         if not isinstance(validators, (list, tuple)):
             raise ImproperlyConfigured("validators must be a list")
 
-        for validate in validators:
-            if isinstance(validate, tuple):
-                if len(validate) <= 1:
-                    raise ImproperlyConfigured("You are passing a tuple validator with no params %s" % str(validate))
-                func = util.get_callable(validate[0])
+        for validator in validators:
+            if isinstance(validator, tuple):
+                if len(validator) <= 1:
+                    raise ImproperlyConfigured("You are passing a tuple validator without args %s" % str(validator))
+                func = get_callable(validator[0])
                 # Using a python slice to get all items after the first to build function args
-                args = validate[1:]
+                args = validator[1:]
+                # Pass the request as first arg by default
                 return func(self.request, *args)
             else:
-                func = util.get_callable(validate)
+                func = get_callable(validator)
                 return func or func(self.request) # pragma: no cover
 
-    def has_name(self, item_dict):
+    def _has_attr(self, item_dict, attr):
+        """
+        Given a menu item dictionary, it returns true if an attr is set.
+        """
+        if item_dict.get(attr, False):
+            return True
+        return False
+
+    def _get_icon(self, parent_dict):
         """
-        Given a menu item dictionary, it returns true if attribute `name` is set.
+        Given a menu item dictionary, this returns an icon class if one exist, or
+        returns an empty string.
         """
-        yep = True
-        if not item_dict.get('name', False):
-            yep = False
-        return yep
+        return parent_dict.get('icon_class', '')
 
-    def get_url(self, item_dict):
+    def _get_url(self, item_dict):
         """
         Given a menu item dictionary, it returns the URL or an empty string.
         """
-        final_url = ''
         url = item_dict.get('url', '')
         try:
             final_url = reverse(**url) if type(url) is dict else reverse(url)
         except NoReverseMatch:
             final_url = url
         return final_url
 
-    def has_url(self, item_dict):
-        """
-        Given a menu item dictionary, it returns true if attribute `url` is set.
-        """
-        if not self.get_url(item_dict):
-            return False
-        return True
-
-    def is_selected(self, item_dict):
+    def _is_selected(self, item_dict):
         """
         Given a menu item dictionary, it returns true if `url` is on path.
         """
-        url = self.get_url(item_dict)
-        if len(url) and url == self.path:
-            return True
-        return False
+        url = self._get_url(item_dict)
+        return url == self.path
 
-    def process_breadcrums(self, menu_list):
+    def _process_breadcrums(self, menu_list):
         """
         Given a menu list, it marks the items on the current path as selected, which
         can be used as breadcrumbs
         """
         for item in menu_list:
             if item['submenu']:
-                item['selected'] = self.process_breadcrums(item['submenu'])
+                item['selected'] = self._process_breadcrums(item['submenu'])
             if item['selected']:
                 return True
         return False
 
-    def get_submenu_list(self, parent_dict, depth):
+    def _get_submenu_list(self, parent_dict):
         """
         Given a menu item dictionary, it returns a submenu if one exist, or
         returns None.
         """
         submenu = parent_dict.get('submenu', None)
-        if submenu is not None:
+        if submenu:
             for child_dict in submenu:
-                child_dict['validators'] = list(set(list(parent_dict.get('validators', [])) +
-                    list(child_dict.get('validators', []))))
-            submenu = self.generate_menu(submenu, depth)
+                # This does a join between the menu item validators and submenu item validators and stores it on the
+                # submenu's validators
+                child_dict['validators'] = list(
+                    set(list(parent_dict.get('validators', [])) + list(child_dict.get('validators', [])))
+                )
+            submenu = self.generate_menu(submenu)
             if not submenu:
                 submenu = None
         return submenu
 
-    def get_menu_list(self, list_dict):
+    def _get_menu_list(self, list_dict):
         """
         A generator that returns only the visible menu items.
         """
         for item in list_dict:
-            if self.has_name(item) and self.has_url(item):
-                if self.is_validated(item):
+            if self._has_attr(item, 'name') and self._has_attr(item, 'url'):
+                if self._is_validated(item):
                     yield copy.copy(item)
 
-    def generate_menu(self, list_dict, depth=None):
+    def generate_menu(self, list_dict):
         """
         Given a list of dictionaries, returns a menu list.
         """
         visible_menu = []
-        current_depth = depth or 0
-        for item in self.get_menu_list(list_dict):
-            item['depth'] = current_depth
-            item['url'] = self.get_url(item)
-            item['selected'] = self.is_selected(item)
-            item['submenu'] = self.get_submenu_list(item, depth=current_depth + 1)
+        for item in self._get_menu_list(list_dict):
+            item['url'] = self._get_url(item)
+            item['selected'] = self._is_selected(item)
+            item['submenu'] = self._get_submenu_list(item)
+            item['icon_class'] = self._get_icon(item)
             visible_menu.append(item)
 
-        self.process_breadcrums(visible_menu)
+        self._process_breadcrums(visible_menu)
 
         return visible_menu
 

menu_generator/templatetags/menu_generator.py

@@ -1,35 +1,12 @@
 from django import template
 from django.conf import settings
 
-from ..utils import get_callable
+from .utils import get_menu_from_apps
+from .. import defaults
 from ..menu import generate_menu
-from .. import defaults as defs
 
 register = template.Library()
 
-MENU_DICT = ".menus.MENUS"
-
-
-def get_menu_from_apps(menu_name):
-    """
-    Returns a consumable menulist for a given menu_name found in each menus.py file (if exists) on each app on
-    INSTALLED_APPS
-    :param menu_name: String, name of the menu to be found
-    :return: Consumable menu list
-    """
-    installed_apps = getattr(settings, "INSTALLED_APPS", [])
-    menu_list = []
-    for app in installed_apps:
-        try:
-            all_menus_dict = get_callable(app + MENU_DICT)
-        except ImportError:
-            all_menus_dict = None
-        except AttributeError:
-            all_menus_dict = None
-        if all_menus_dict:
-            menu_list += all_menus_dict.get(menu_name, [])
-    return menu_list
-
 
 @register.assignment_tag(takes_context=True)
 def get_menu(context, menu_name):
@@ -39,11 +16,16 @@ def get_menu(context, menu_name):
 
     Update, March 18 2017: Now the function get the menu list from settings and append more items if found on the
     menus.py's 'MENUS' dict.
+    :param context: Template context
+    :param menu_name: String, name of the menu to be found
+    :return: Generated menu
     """
-    menu_list = getattr(settings, menu_name, defs.MENU_NOT_FOUND)
+    menu_list = getattr(settings, menu_name, defaults.MENU_NOT_FOUND)
     menu_from_apps = get_menu_from_apps(menu_name)
-    if menu_list == defs.MENU_NOT_FOUND and menu_from_apps:
+    # If there isn't a menu on settings but there is menu from apps we built menu from apps
+    if menu_list == defaults.MENU_NOT_FOUND and menu_from_apps:
         menu_list = menu_from_apps
-    elif menu_list != defs.MENU_NOT_FOUND and menu_from_apps:
+    # It there is a menu on settings and also on apps we merge both menus
+    elif menu_list != defaults.MENU_NOT_FOUND and menu_from_apps:
         menu_list += menu_from_apps
     return generate_menu(context['request'], menu_list)

menu_generator/templatetags/utils.py

@@ -0,0 +1,25 @@
+from django.conf import settings
+from menu_generator.utils import get_callable
+
+MENU_DICT = ".menus.MENUS"
+
+
+def get_menu_from_apps(menu_name):
+    """
+    Returns a consumable menulist for a given menu_name found in each menus.py file (if exists) on each app on
+    INSTALLED_APPS
+    :param menu_name: String, name of the menu to be found
+    :return: Consumable menu list
+    """
+    installed_apps = getattr(settings, "INSTALLED_APPS", [])
+    menu_list = []
+    for app in installed_apps:
+        try:
+            all_menus_dict = get_callable(app + MENU_DICT)
+        except ImportError:
+            all_menus_dict = None
+        except AttributeError:
+            all_menus_dict = None
+        if all_menus_dict:
+            menu_list += all_menus_dict.get(menu_name, [])
+    return menu_list