Login

Class Feeds DRY TemplateTag

Author:
gmandx
Posted:
May 14, 2010
Language:
Python
Version:
1.1
Score:
0 (after 0 ratings)

I'm using the Django Feeds Framework and it's really nice, very intuitive and easy to use. But, I think there is a problem when creating links to feeds in HTML.

For example:

<link rel="alternate" type="application/rss+xml" title="{{ feed_title }}" href="{{ url_of_feed }}" />

Link's HREF attribute can be easily found out, just use reverse()

But, what about the TITLE attribute? Where the template engine should look for this? Even more, what if the feed is build up dinamically and the title depends on parameters (like this)?

This is the solution I came up with. However, as you can see, there is some caveats: Requires Django 1.2 Class Feeds, don't know exactly how to do this with the old way of feeds. If the feed class uses the request object, the request context processor must be configured, since None is passed if it isn't present in the context. * There's an oddity with Feed.__get_dynamic_attr(). The Feed subclass instance doesn't have this method; instead, it appears with another name. Don't know how to figure the name out at runtime...

I've posted this problem on StackOverflow, but didn't get a better answer.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
#coding:utf-8

import re

from django import template
from django.conf import settings
from django.contrib.syndication.views import Feed
from django.core.urlresolvers import reverse, resolve, NoReverseMatch
from django.template import Node
from django.template import TemplateSyntaxError
from django.utils.encoding import smart_str
from django.utils.html import escape as html_escape
from django.utils.safestring import mark_safe

register = template.Library()

kwarg_re = re.compile(r"(?:(\w+)=)?(.+)")

class FeedInfoNode(Node):
    def __init__(self, view_name, args, kwargs, asvar):
        self.view_name = view_name
        self.args = args
        self.kwargs = kwargs
        self.asvar = asvar

    def render(self, context):
        args = [arg.resolve(context) for arg in self.args]
        kwargs = dict([(smart_str(k,'ascii'), v.resolve(context))
                       for k, v in self.kwargs.items()])

        # Try to look up the URL twice: once given the view name, and again
        # relative to what we guess is the "main" app. If they both fail,
        # re-raise the NoReverseMatch unless we're using the
        # {% feed_info ... as var %} construct in which cause return nothing.
        url = ''
        try:
            url = reverse(self.view_name, args=args, kwargs=kwargs, current_app=context.current_app)
        except NoReverseMatch, e:
            if settings.SETTINGS_MODULE:
                project_name = settings.SETTINGS_MODULE.split('.')[0]
                try:
                    url = reverse(project_name + '.' + self.view_name,
                                  args=args, kwargs=kwargs,
                                  current_app=context.current_app)
                except NoReverseMatch:
                    if self.asvar is None:
                        # Re-raise the original exception, not the one with
                        # the path relative to the project. This makes a
                        # better error message.
                        raise e
            else:
                if self.asvar is None:
                    raise e

        if url:
            if 'request' in context:
                request = context['request']
            else:
                request = None

            feed_instance, feed_args, feed_kwargs = resolve(url)
            if not isinstance(feed_instance, Feed):
                raise NoReverseMatch, \
                      'feed_info can only reverse class-based feeds'

            feed_obj = feed_instance.get_object(request, *feed_args, **feed_kwargs)

            feed_data = {
                'url': url,
                'obj': feed_instance,
                'args': feed_args,
                'kwargs': feed_kwargs,
                #'title': html_escape(feed_instance.__get_dynamic_attr('title', obj)),
                'title': html_escape(
                    feed_instance._Feed__get_dynamic_attr('title', feed_obj)
                    ),
                'type': feed_instance.feed_type.mime_type,
            }

        if self.asvar:
            if url:
                context[self.asvar] = feed_data
            else:
                context[self.asvar] = {}
            return ''
        else:
            return mark_safe(
                '<link rel="alternate" type="%(type)s" title="%(title)s" href="%(url)s" />' \
                % feed_data
            )

def feed_info(parser, token):
    """
    Returns an mapping containing populated info about the reversed feed
    Works exactly as the url tag, but the mapping is not returned, instead
    a variable is always set  in the context.

    This is a way to define links that aren't tied to a particular URL
    configuration::

        {% feed_info path.to.some_feed_view_class arg1 arg2 as feed_info_var %}

        or

        {% feed_info path.to.some_feed_view_class name1=value1 name2=value2 as feed_info_var %}
    """

    bits = token.split_contents()
    if len(bits) < 2:
        raise TemplateSyntaxError("'%s' takes at least one argument"
                                  " (path to a feed view)" % bits[0])
    viewname = bits[1]
    args = []
    kwargs = {}
    asvar = None
    bits = bits[2:]
    if len(bits) >= 2 and bits[-2] == 'as':
        asvar = bits[-1]
        bits = bits[:-2]

    # Backwards compatibility: check for the old comma separated format
    # {% url urlname arg1,arg2 %}
    # Initial check - that the first space separated bit has a comma in it
    if bits and ',' in bits[0]:
        check_old_format = True
        # In order to *really* be old format, there must be a comma
        # in *every* space separated bit, except the last.
        for bit in bits[1:-1]:
            if ',' not in bit:
                # No comma in this bit. Either the comma we found
                # in bit 1 was a false positive (e.g., comma in a string),
                # or there is a syntax problem with missing commas
                check_old_format = False
                break
    else:
        # No comma found - must be new format.
        check_old_format = False

    if check_old_format:
        # Confirm that this is old format by trying to parse the first
        # argument. An exception will be raised if the comma is
        # unexpected (i.e. outside of a static string).
        match = kwarg_re.match(bits[0])
        if match:
            value = match.groups()[1]
            try:
                parser.compile_filter(value)
            except TemplateSyntaxError:
                bits = ''.join(bits).split(',')

    # Now all the bits are parsed into new format,
    # process them as template vars
    if len(bits):
        for bit in bits:
            match = kwarg_re.match(bit)
            if not match:
                raise TemplateSyntaxError(u"Malformed arguments to url tag")
            name, value = match.groups()
            if name:
                kwargs[name] = parser.compile_filter(value)
            else:
                args.append(parser.compile_filter(value))

    return FeedInfoNode(viewname, args, kwargs, asvar)

feed_info = register.tag(feed_info)

More like this

  1. Template tag - list punctuation for a list of items by shapiromatron 9 months ago
  2. JSONRequestMiddleware adds a .json() method to your HttpRequests by cdcarter 9 months, 1 week ago
  3. Serializer factory with Django Rest Framework by julio 1 year, 3 months ago
  4. Image compression before saving the new model / work with JPG, PNG by Schleidens 1 year, 4 months ago
  5. Help text hyperlinks by sa2812 1 year, 5 months ago

Comments

Please login first before commenting.