Django干饲料

我正在使用Django Feeds框架，它非常好，非常直观，易于使用。但是，我认为在HTML中创建指向提要的链接时存在问题

例如：

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

链接的

HREF

属性很容易找到，只需使用

reverse（）

但是，

标题

属性呢？模板引擎应该在何处查找此内容？更重要的是，如果feed是以动态方式构建的，并且标题取决于参数（例如）

我想不出一个对我来说“似乎”枯燥的解决方案。。。我所能想到的就是使用上下文处理器和模板标记，但是当上下文处理器/模板标记必须找到参数来构造提要类时，它会变得很混乱，写这篇文章时我意识到我自己甚至不知道如何在视图中创建提要实例

---

如果我把所有这些逻辑放在视图中，它将不仅仅是一个视图。另外，

TITLE

的值将出现在视图和提要中。

只是一个猜测（因为我还没有在django应用程序中使用提要），但您可以在提要对象中为提要添加一个特殊的模板上下文，并在base.html中使用它。

我对这个解决方案并不完全满意，它可能会使用

请求

中断提要，这取决于一种神奇的方法。就这样：

#coding:utf-8
# Author: Armando Pérez Marqués <mandx@rbol.org>
# Purpose: Django TemplateTag to output feed links in templates in a DRY way
# Created: 05/07/2010

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 '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:
            context[self.asvar] = feed_data
            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("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)

#编码：utf-8
#作者：Armando Pérez Markés
#用途：Django TemplateTag以干燥方式输出模板中的提要链接
#创建日期：2010年7月5日
进口稀土
从django导入模板
从django.conf导入设置
从django.contrib.syndication.views导入提要
从django.core.urlResolver导入反向、解析、NoReverseMatch
从django.template导入节点
从django.template导入TemplateSyntaxError
从django.utils.encoding导入智能\u str
从django.utils.html导入转义为html\u转义
从django.utils.safestring导入标记_safe
register=template.Library（）
kwarg_re=re.compile（r“（？：（\w+）=）？（.+）”）
类FeedInfoNode（节点）：
定义初始化（self，view，name，args，kwargs，asvar）：
self.view\u name=视图\u name
self.args=args
self.kwargs=kwargs
self.asvar=asvar
def呈现（自身、上下文）：
args=[self.args中arg的arg.resolve（上下文）]
kwargs=dict（[（smart_str（k，'ascii'），v.resolve（context））
对于self.kwargs.items（）中的k，v）
#尝试查找URL两次：一次给定视图名称，另一次
#相对于我们猜测的“主”应用程序。如果他们都失败了，
#重新启动NoReverseMatch，除非我们使用
#{%feed_info…作为var%}构造，其中cause不返回任何内容。
url=“”
尝试：
url=reverse（self.view\u name，args=args，kwargs=kwargs，current\u app=context.current\u app）
除NoReverseMatch外，e：
如果设置.settings\u模块：
项目名称=设置。设置\u模块。拆分（'.'）[0]
尝试：
url=reverse（项目名称+“.+self.view\u名称，
args=args，kwargs=kwargs，current\u app=context.current\u app）
除NoReverseMatch外：
如果self.asvar为无：
#重新引发原始异常，而不是具有
#相对于项目的路径。这是一个很好的例子
#更好的错误消息。
提高e
其他：
如果self.asvar为无：
提高e
如果上下文中有“请求”：
请求=上下文['request']
其他：
请求=无
提要实例，提要参数，提要kwargs=resolve（url）
如果不是isinstance（提要\实例，提要）：
提高诺维塞马奇\
“源信息只能反转基于类的源”
feed_obj=feed_instance.get_对象（请求，*feed_参数，**feed_参数）
feed_数据={
“url”：url，
“obj”：提要_实例，
“args”：提要参数，
“kwargs”：feed_kwargs，
#“title”：html_转义（提要_实例._获取_动态_属性（'title'，obj）），
“标题”：html\u转义(
提要\实例。\提要\获取\动态\属性（'title'，提要\对象）
),
“类型”：提要\实例。提要\类型。mime\类型，
}
如果self.asvar：
上下文[self.asvar]=提要数据
返回“”
其他：
安全返回标记(
'' \
%feed_数据
)
def提要_信息（解析器、令牌）：
"""
返回一个映射，其中包含有关反向提要的填充信息
与url标记完全相同，但不会返回映射
变量始终在上下文中设置。
这是一种定义不绑定到特定URL的链接的方法
配置：：
{%feed_info path.to.some_feed_查看_类arg1 arg2作为feed_info_var%}
或
{%feed_info path.to.some_feed_view_class name1=value1 name2=value2 as feed_info_var%}
"""
位=标记。拆分内容（）
如果len（位）<2：
raise TemplateSyntaxError（“%s”至少接受一个参数）
“（提要视图的路径）”%bits[0]）
viewname=位[1]
args=[]
kwargs={}
asvar=无
位=位[2:]
如果len（位）>=2，位[-2]='as'：
asvar=位[-1]
位=位[：-2]
#向后兼容性：检查旧的逗号分隔格式
#{%url url url名称arg1，arg2%}
#初始检查-第一个空格分隔的位是否包含逗号
如果位和“，”以位[0]表示：
检查\u old\u format=True
#为了*真正*成为旧格式，必须有逗号
#在*每个*空格中分隔位，最后一位除外。
对于位[1:-1]中的位：
如果“，”不在位中：
#这一位没有逗号。要么是我们找到的逗号
#第1位为假阳性(