Ticket #6700: smart_decorator.diff

django/utils/decorators.py

@@ -1 @@
-"Functions that help with dynamically creating decorators for views."
+"Functions that help with creating decorators."
 
 import types
+from inspect import getargspec
 try:
     from functools import wraps
 except ImportError:
     from django.utils.functional import wraps  # Python 2.3, 2.4 fallback.
 
+def smart_decorator(decorator):
+    """
+    Smartens up "decorators" which accept additional arguments.
+
+    It allows the decorator to be called correctly in any of the following
+    formats::
+
+        @my_smartened_decorator(arg1, arg2)
+        my_func = my_smartened_decorator(arg1, arg2)(my_func)
+        my_func = my_smartened_decorator(my_func, arg1, arg2)
+
+    If all additional decorator arguments have defaults, it also allows for the
+    following formats::
+
+        @my_smartened_decorator
+        my_func = my_smartened_decorator(my_func)
+    """
+    def _simple_dec(function):
+        return decorator(function)
+    def _dec_with_args(*args, **kwargs):
+        def _inner_dec(function):
+            return decorator(function, *args, **kwargs)
+        return wraps(decorator)(_inner_dec)
+    def _smart_dec(function_or_value, *args, **kwargs):
+        if not isinstance(function_or_value, types.FunctionType):
+            args = (function_or_value,) + args
+            return _dec_with_args(*args, **kwargs)
+        return decorator(function_or_value, *args, **kwargs)
+    args, varargs, varkw, defaults = getargspec(decorator)
+    assert args, 'Decorators must take at least one argument'
+    if not varargs and not varkw:
+        if len(args) == 1:
+            return wraps(decorator)(_simple_dec)
+        if len(defaults) == len(args) - 1:
+            return wraps(decorator)(_smart_dec)
+    return wraps(decorator)(_dec_with_args)
+
 def decorator_from_middleware(middleware_class):
     """
     Given a middleware class (not an instance), returns a view decorator. This

tests/regressiontests/utils/decorators.py

@@ +1 @@
+r"""
+>>> from django.utils.decorators import smart_decorator, wraps
+
+>>> def ping(extra_text=''):
+...     "Simple ping method"
+...     print extra_text or 'ping'
+
+>>> def my_dec(func, arg='arg1', arg2=None):
+...     print arg
+...     if arg2:
+...         print 'arg2:', arg2
+...     def _dec(*args, **kwargs):
+...         return func(*args, **kwargs)
+...     return wraps(func)(_dec)
+>>> my_dec = smart_decorator(my_dec)
+
+# It accepts just the function
+>>> p1 = my_dec(ping)
+arg1
+
+# ... or the function and arguments
+>>> p2 = my_dec(ping, 'two')
+two
+>>> p2 = my_dec(ping, arg2='two')
+arg1
+arg2: two
+
+# ... or the 2.4 syntax of (arguments)(function)
+>>> p3 = my_dec('three')(ping)
+three
+
+# In any of those cases, the actual decorated function still works fine:
+>>> p1()
+ping
+>>> p1('pong')
+pong
+>>> p1(extra_text='pang')
+pang
+>>> p2()
+ping
+>>> p2('pong')
+pong
+>>> p2(extra_text='pang')
+pang
+>>> p3()
+ping
+>>> p3('pong')
+pong
+>>> p3(extra_text='pang')
+pang
+
+>>> p1.__doc__
+'Simple ping method'
+>>> p2.__doc__
+'Simple ping method'
+>>> p3.__doc__
+'Simple ping method'
+"""

tests/regressiontests/utils/tests.py

@@ -8 +8 @@
 
 import timesince
 import datastructures
+import decorators
 
 # Extra tests
 __test__ = {
     'timesince': timesince,
     'datastructures': datastructures,
+    'decorators': decorators,
 }
 
 class TestUtilsHtml(TestCase):