Snippet List
This code is taken from a [Stack Overflow answer by Will Hardy](http://stackoverflow.com/questions/3715550/creating-a-list-on-the-fly-in-a-django-template/3715794#3715794).
Usage: `{% collect var1 var2 'foo' 'bar' 5 as some_list %}`.
Sometimes one wishes to create a list on the fly within a template. Perhaps a collection needs to be passed to a template filter, but the collection cannot be created in the view since the values of one or more of its items are set in the template.
A contrived example:
{% with 5 as max %}{% with posts|length as len %}
{% for post in posts %}
{% if forloop.counter <= max %}
{% include 'excerpt.dhtml' %}
{% endif %}
{% endfor %}
{% collect len max as limits %}
<p>Displaying {{ limits|minimum }} of {{ len }} post{{ posts|pluralize }}.</p>
{% endwith %}{% endwith %}
The final line will state how many posts are displayed: something like "5 of 24" or "2 of 2".
This particular problem can be solved in a number of other ways, some of which are more appropriate. Having a template tag that can create lists on the fly is potentially useful in quite a few situations, though.
I don't know whether this need is common enough to warrant being in the core. If something like this is to be included one day, it'd be much nicer to overload the `with` tag than to introduce a new tag. `{% with var1 var2 var3 as some_list %}` reads well.
Defining a custom template tag consists of three parts: a compiling function, a rendering `Node` subclass and a tag registration with `register.tag()`. The latter can be used as a (function) decorator on the compiling function, simplifying things into two parts.
A neat fact is that `register.tag()` can actually be used as a class decorator in Python 2.6+ to condense all steps into the `Node` subclass. The compiling function simply becomes the `__init__()`. Below are two variants of the 'current_time' tag example from the Django docs: the first passing an explicit tag name and the second using the class name instead.
- template-tags
- class-decorator
Jinja2 is an alternative template system that can be plugged into django.
It offers greator flexibility in presentation logic; if you find the django template system too restrictive, you should have a look at Jinja2
(The syntax is very similar).
In Jinja, you don't need costum tags (most of the time), because you can call functions and pass them parameters too!
The only problem is that you cannot "load" functions from the template, this "loading" must be done by the code that renders the template. Same goes for filters and tests.
If you need only two or three functions/filters, no problem, you can manually add them to the Environment object; but this method doesn't really scale with real-life webapps.
This module/snippet offers a solution by allowing the user to define application-specific functions and filters and load them into the jinja2 environment automatically.
Here's how to use this:
1. Install Jinja2 (for a quick & dirty installation, you can just put the jinja2 folder in a folder that's in PYTHONPATH)
2. Save this python module somewhere and call it something meaningful (I have it as jinja.py in my project directory)
3. Whenever you need to respond (an HttpResponse) with a template that's rendered by jinja, import this module and call `return jrespond( template_name, context )`
4. Any filters or functions you define in any of your applications will be readily available inside the template (see the documentation in code)
- template
- templates
- jinja
- template-tags
- jinja2
This is a mod I made to the Django simple_tag system to let the simple_tags access comments. I plan to try and get it integrated into the trunk, so it's mainly here so (a) the people on django-developers can see it, and (b) while I'm waiting, or if it doesn't get put in the trunk, people can use it.
**Installing**
1. Open the module `django.template.__init__`, wherever that lives.
2. Scroll down to the beginning of " `class Library:` "
3. Find the simple_tag function (" `def simple_tag(self,func):` ")
4. Replace the function (even the whitespace before each line) with the code snippet.
**Usage**
1. When defining a simple tag (see the [docs](http://docs.djangoproject.com/en/dev/howto/custom-template-tags/#shortcut-for-simple-tags) for more info), have the first parameter in your function be named "`context`". Otherwise, an error will be thrown. It can accept other parameters like normal.
2. Use `register.simple_tag(my_function_name, takes_context=True)` to register your function as one that will use the context.
3. The tag's function can access the context like a dictionary - to get a value, just use `context['cheese']`, or to set one, use `context['cheese'] = 'Limberger'`. Due to the context's mutability, this will affect the context in the main template as well.
**Notes**
This code hasn't been tested in a "production environment", but I did test my modifications thoroughly, and if you don't add `takes_context=True`, `simple_tag` will behave exactly as normal. Of course, if there is a problem, make sure you leave a comment.
**Code**
Since most of the code is hacked up from other Django library functions, and to prepare for if and when it's merged into the trunk, it's released under the BSD license.
- template
- template-tags
- template-engine
Based on [this snippet](http://www.djangosnippets.org/snippets/660/), adapted to split a list into *n* number of sublists, e.g. split a list of results into three evenly-divided sublists to enable display of the results in three columns on one page with CSS.
Tag: `{% list_to_columns your_list as new_list number_of_columns %}`
The split_seq solution comes from a comment by Sebastian Hempel on [this post](http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/425397).
More info [here](http://herself.movielady.net/2008/07/16/split-list-to-columns-django-template-tag/).
- template
- list
- template-tags
The problem was to output self-related objects (like category objects which may be a sub-category in any category and so on) in unordered list with links to certain view (providing some object.id arg). Its somewhat like unordered_list tag but takes plain list of objects and provides links.
For example:
category_list = Category.objects.all()
In your template:
{% related_linked_list category_list view_category %}
This tag, however, have some limits:
1. Model shoud have self-related "parent" and id that may be passed into view.
2. In model parent = ForeignKey('self', ...) *related_name* is "child_set".
But its simple enough that you may easily rewrite it for your own needs. :)
6 snippets posted so far.