Fixed #17135 -- Made it possible to use decorators (like stringfilter) on...

register = template.Library()

@register.filter

@register.filter(is_safe=True)

def ordinal(value):

    """

    Converts an integer to its ordinal as a string. 1 is '1st', 2 is '2nd',

    if value % 100 in (11, 12, 13): # special case

        return u"%d%s" % (value, suffixes[0])

    return u"%d%s" % (value, suffixes[value % 10])

ordinal.is_safe = True

@register.filter

@register.filter(is_safe=True)

def intcomma(value, use_l10n=True):

    """

    Converts an integer to a string containing commas every three digits.

        return new

    else:

        return intcomma(new, use_l10n)

intcomma.is_safe = True

# A tuple of standard large number to their converters

intword_converters = (

    )),

)

@register.filter

@register.filter(is_safe=False)

def intword(value):

    """

    Converts a large integer to a friendly text representation. Works best

            new_value = value / float(large_number)

            return _check_for_i18n(new_value, *converters(new_value))

    return value

intword.is_safe = False

@register.filter

@register.filter(is_safe=True)

def apnumber(value):

    """

    For numbers 1-9, returns the number spelled out. Otherwise, returns the

    if not 0 < value < 10:

        return value

    return (_('one'), _('two'), _('three'), _('four'), _('five'), _('six'), _('seven'), _('eight'), _('nine'))[value-1]

apnumber.is_safe = True

@register.filter

def naturalday(value, arg=None):

register = template.Library()

@register.filter

@register.filter(is_safe=True)

def textile(value):

    try:

        import textile

        return force_unicode(value)

    else:

        return mark_safe(force_unicode(textile.textile(smart_str(value), encoding='utf-8', output='utf-8')))

textile.is_safe = True

@register.filter

@register.filter(is_safe=True)

def markdown(value, arg=''):

    """

    Runs Markdown over a given value, optionally using various

                return mark_safe(markdown.markdown(force_unicode(value), extensions, safe_mode=safe_mode))

        else:

            return mark_safe(force_unicode(markdown.markdown(smart_str(value))))

markdown.is_safe = True

@register.filter

@register.filter(is_safe=True)

def restructuredtext(value):

    try:

        from docutils.core import publish_parts

        docutils_settings = getattr(settings, "RESTRUCTUREDTEXT_FILTER_SETTINGS", {})

        parts = publish_parts(source=smart_str(value), writer_name="html4css1", settings_overrides=docutils_settings)

        return mark_safe(force_unicode(parts["fragment"]))

restructuredtext.is_safe = True

        self.tags[getattr(func, "_decorated_function", func).__name__] = func

        return func

    def filter(self, name=None, filter_func=None):

    def filter(self, name=None, filter_func=None, **flags):

        if name is None and filter_func is None:

            # @register.filter()

            return self.filter_function

        elif filter_func is None:

            def dec(func):

                return self.filter_function(func, **flags)

            return dec

        elif name is not None and filter_func is None:

            if callable(name):

                # @register.filter

                return self.filter_function(name)

                return self.filter_function(name, **flags)

            else:

                # @register.filter('somename') or @register.filter(name='somename')

                def dec(func):

                    return self.filter(name, func)

                    return self.filter(name, func, **flags)

                return dec

        elif name is not None and filter_func is not None:

            # register.filter('somename', somefunc)

            self.filters[name] = filter_func

            for attr in ('is_safe', 'needs_autoescape'):

                if attr in flags:

                    value = flags[attr]

                    # set the flag on the filter for FilterExpression.resolve

                    setattr(filter_func, attr, value)

                    # set the flag on the innermost decorated function

                    # for decorators that need it e.g. stringfilter

                    if hasattr(filter_func, "_decorated_function"):

                        setattr(filter_func._decorated_function, attr, value)

            return filter_func

        else:

            raise InvalidTemplateLibrary("Unsupported arguments to "

                "Library.filter: (%r, %r)", (name, filter_func))

    def filter_function(self, func):

        self.filters[getattr(func, "_decorated_function", func).__name__] = func

        return func

    def filter_function(self, func, **flags):

        name = getattr(func, "_decorated_function", func).__name__

        return self.filter(name, func, **flags)

    def simple_tag(self, func=None, takes_context=None, name=None):

        def dec(func):

        if args:

            args = list(args)

            args[0] = force_unicode(args[0])

            if isinstance(args[0], SafeData) and getattr(func, 'is_safe', False):

            if (isinstance(args[0], SafeData) and

                getattr(_dec._decorated_function, 'is_safe', False)):

                return mark_safe(func(*args, **kwargs))

        return func(*args, **kwargs)

    # Include a reference to the real function (used to check original

    # arguments by the template parser).

    # arguments by the template parser, and to bear the 'is_safe' attribute

    # when multiple decorators are applied).

    _dec._decorated_function = getattr(func, '_decorated_function', func)

    for attr in ('is_safe', 'needs_autoescape'):

        if hasattr(func, attr):

            import warnings

            warnings.warn("Setting the %s attribute of a template filter "

                          "function is deprecated; use @register.filter(%s=%s) "

                          "instead" % (attr, attr, getattr(func, attr)),

                          PendingDeprecationWarning)

            setattr(_dec, attr, getattr(func, attr))

    return wraps(func)(_dec)

###################

# STRINGS         #

###################

@register.filter

@register.filter(is_safe=True)

@stringfilter

def addslashes(value):

    """

    filter instead.

    """

    return value.replace('\\', '\\\\').replace('"', '\\"').replace("'", "\\'")

addslashes.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def capfirst(value):

    """Capitalizes the first character of the value."""

    return value and value[0].upper() + value[1:]

capfirst.is_safe = True

@register.filter("escapejs")

@stringfilter

    """Hex encodes characters for use in JavaScript strings."""

    return escapejs(value)

@register.filter("fix_ampersands")

@register.filter("fix_ampersands", is_safe=True)

@stringfilter

def fix_ampersands_filter(value):

    """Replaces ampersands with ``&`` entities."""

    return fix_ampersands(value)

fix_ampersands_filter.is_safe = True

# Values for testing floatformat input against infinity and NaN representations,

# which differ across platforms and Python versions.  Some (i.e. old Windows

nan = (1e200 * 1e200) // (1e200 * 1e200)

special_floats = [str(pos_inf), str(neg_inf), str(nan)]

@register.filter

@register.filter(is_safe=True)

def floatformat(text, arg=-1):

    """

    Displays a float to a specified number of decimal places.

        return mark_safe(formats.number_format(number, abs(p)))

    except InvalidOperation:

        return input_val

floatformat.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def iriencode(value):

    """Escapes an IRI value for use in a URL."""

    return force_unicode(iri_to_uri(value))

iriencode.is_safe = True

@register.filter

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def linenumbers(value, autoescape=None):

    """Displays text with line numbers."""

        for i, line in enumerate(lines):

            lines[i] = (u"%0" + width  + u"d. %s") % (i + 1, escape(line))

    return mark_safe(u'\n'.join(lines))

linenumbers.is_safe = True

linenumbers.needs_autoescape = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def lower(value):

    """Converts a string into all lowercase."""

    return value.lower()

lower.is_safe = True

@register.filter

@register.filter(is_safe=False)

@stringfilter

def make_list(value):

    """

    For a string, it's a list of characters.

    """

    return list(value)

make_list.is_safe = False

@register.filter

@register.filter(is_safe=True)

@stringfilter

def slugify(value):

    """

    value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore')

    value = unicode(re.sub('[^\w\s-]', '', value).strip().lower())

    return mark_safe(re.sub('[-\s]+', '-', value))

slugify.is_safe = True

@register.filter

@register.filter(is_safe=True)

def stringformat(value, arg):

    """

    Formats the variable according to the arg, a string formatting specifier.

        return (u"%" + unicode(arg)) % value

    except (ValueError, TypeError):

        return u""

stringformat.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def title(value):

    """Converts a string into titlecase."""

    t = re.sub("([a-z])'([A-Z])", lambda m: m.group(0).lower(), value.title())

    return re.sub("\d([A-Z])", lambda m: m.group(0).lower(), t)

title.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def truncatechars(value, arg):

    """

    except ValueError: # Invalid literal for int().

        return value # Fail silently.

    return Truncator(value).chars(length)

truncatechars.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def truncatewords(value, arg):

    """

    except ValueError: # Invalid literal for int().

        return value # Fail silently.

    return Truncator(value).words(length, truncate=' ...')

truncatewords.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def truncatewords_html(value, arg):

    """

    except ValueError: # invalid literal for int()

        return value # Fail silently.

    return Truncator(value).words(length, html=True, truncate=' ...')

truncatewords_html.is_safe = True

@register.filter

@register.filter(is_safe=False)

@stringfilter

def upper(value):

    """Converts a string into all uppercase."""

    return value.upper()

upper.is_safe = False

@register.filter

@register.filter(is_safe=False)

@stringfilter

def urlencode(value, safe=None):

    """

    if safe is not None:

        kwargs['safe'] = safe

    return urlquote(value, **kwargs)

urlencode.is_safe = False

@register.filter

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def urlize(value, autoescape=None):

    """Converts URLs in plain text into clickable links."""

    return mark_safe(urlize_impl(value, nofollow=True, autoescape=autoescape))

urlize.is_safe = True

urlize.needs_autoescape = True

@register.filter

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def urlizetrunc(value, limit, autoescape=None):

    """

    """

    return mark_safe(urlize_impl(value, trim_url_limit=int(limit), nofollow=True,

                            autoescape=autoescape))

urlizetrunc.is_safe = True

urlizetrunc.needs_autoescape = True

@register.filter

@register.filter(is_safe=False)

@stringfilter

def wordcount(value):

    """Returns the number of words."""

    return len(value.split())

wordcount.is_safe = False

@register.filter

@register.filter(is_safe=True)

@stringfilter

def wordwrap(value, arg):

    """

    Argument: number of characters to wrap the text at.

    """

    return wrap(value, int(arg))

wordwrap.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def ljust(value, arg):

    """

    Argument: field size.

    """

    return value.ljust(int(arg))

ljust.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def rjust(value, arg):

    """

    Argument: field size.

    """

    return value.rjust(int(arg))

rjust.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def center(value, arg):

    """Centers the value in a field of a given width."""

    return value.center(int(arg))

center.is_safe = True

@register.filter

@stringfilter

# HTML STRINGS    #

###################

@register.filter("escape")

@register.filter("escape", is_safe=True)

@stringfilter

def escape_filter(value):

    """

    Marks the value as a string that should not be auto-escaped.

    """

    return mark_for_escaping(value)

escape_filter.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def force_escape(value):

    """

    possible escaping).

    """

    return mark_safe(escape(value))

force_escape.is_safe = True

@register.filter("linebreaks")

@register.filter("linebreaks", is_safe=True, needs_autoescape=True)

@stringfilter

def linebreaks_filter(value, autoescape=None):

    """

    """

    autoescape = autoescape and not isinstance(value, SafeData)

    return mark_safe(linebreaks(value, autoescape))

linebreaks_filter.is_safe = True

linebreaks_filter.needs_autoescape = True

@register.filter

@register.filter(is_safe=True, needs_autoescape=True)

@stringfilter

def linebreaksbr(value, autoescape=None):

    """

    if autoescape:

        value = escape(value)

    return mark_safe(value.replace('\n', '<br />'))

linebreaksbr.is_safe = True

linebreaksbr.needs_autoescape = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def safe(value):

    """

    Marks the value as a string that should not be auto-escaped.

    """

    return mark_safe(value)

safe.is_safe = True

@register.filter

@register.filter(is_safe=True)

def safeseq(value):

    """

    A "safe" filter for sequences. Marks each element in the sequence,

    with the results.

    """

    return [mark_safe(force_unicode(obj)) for obj in value]

safeseq.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def removetags(value, tags):

    """Removes a space separated list of [X]HTML tags from the output."""

    value = starttag_re.sub(u'', value)

    value = endtag_re.sub(u'', value)

    return value

removetags.is_safe = True

@register.filter

@register.filter(is_safe=True)

@stringfilter

def striptags(value):

    """Strips all [X]HTML tags."""

    return strip_tags(value)

striptags.is_safe = True

###################

# LISTS           #

###################

@register.filter

@register.filter(is_safe=False)

def dictsort(value, arg):

    """

    Takes a list of dicts, returns that list sorted by the property given in

    the argument.

    """

    return sorted(value, key=Variable(arg).resolve)

dictsort.is_safe = False

@register.filter

@register.filter(is_safe=False)

def dictsortreversed(value, arg):

    """

    Takes a list of dicts, returns that list sorted in reverse order by the

    property given in the argument.

    """

    return sorted(value, key=Variable(arg).resolve, reverse=True)

dictsortreversed.is_safe = False

@register.filter

@register.filter(is_safe=False)

def first(value):

    """Returns the first item in a list."""

    try:

        return value[0]

    except IndexError:

        return u''

first.is_safe = False

@register.filter

@register.filter(is_safe=True, needs_autoescape=True)

def join(value, arg, autoescape=None):

    """

    Joins a list with a string, like Python's ``str.join(list)``.

    except AttributeError: # fail silently but nicely

        return value

    return mark_safe(data)

join.is_safe = True

join.needs_autoescape = True

@register.filter

@register.filter(is_safe=True)

def last(value):

    "Returns the last item in a list"

    try:

        return value[-1]

    except IndexError:

        return u''

last.is_safe = True

@register.filter

@register.filter(is_safe=True)

def length(value):

    """Returns the length of the value - useful for lists."""

    try:

        return len(value)

    except (ValueError, TypeError):

        return ''

length.is_safe = True

@register.filter

@register.filter(is_safe=False)

def length_is(value, arg):

    """Returns a boolean of whether the value's length is the argument."""

    try:

        return len(value) == int(arg)

    except (ValueError, TypeError):

        return ''

length_is.is_safe = False

@register.filter

@register.filter(is_safe=True)

def random(value):

    """Returns a random item from the list."""

    return random_module.choice(value)

random.is_safe = True

@register.filter("slice")

@register.filter("slice", is_safe=True)

def slice_filter(value, arg):

    """

    Returns a slice of the list.

    except (ValueError, TypeError):

        return value # Fail silently.

slice_filter.is_safe = True

@register.filter

@register.filter(is_safe=True, needs_autoescape=True)