3998

pending completion

Build # 3998

Build Type

Pull #3265

travis-ci

Committed by

jezdez

Commit Message

<a href="https://github.com/mozilla/kuma/commit/<a class=hub.com/mozilla/kuma/commit/<a class="double-link" href="https://git"><a class=hub.com/mozilla/kuma/commit/<a class="double-link" href="https://git"><a class=hub.com/mozilla/kuma/commit/<a class="double-link" href="https://git"><a class=hub.com/mozilla/kuma/commit/071df5770e6f9340c8cf09323da76bc5efe2d9a0">071df5770">&lt;a href=&quot;https://github.com/mozilla/kuma/commit/</a><a class="double-link" href="https://github.com/mozilla/kuma/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mozilla/kuma/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mozilla/kuma/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mozilla/kuma/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/mozilla/kuma/commit/071df5770e6f9340c8cf09323da76bc5efe2d9a0">071df5770</a><a href="https://github.com/mozilla/kuma/commit/071df5770e6f9340c8cf09323da76bc5efe2d9a0">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/mozilla/kuma/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/mozilla/kuma/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mozilla/kuma/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mozilla/kuma/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mozilla/kuma/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/mozilla/kuma/commit/071df5770e6f9340c8cf09323da76bc5efe2d9a0&quot;&gt;071df5770&lt;/a&gt;&lt;a href=&quot;https://github.com/mozilla/kuma/commit/071df5770e6f9340c8cf09323da76bc5efe2d9a0&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/mozilla/kuma/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/mozilla/kuma/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot... (continued)

Pull Request Pull Request #3265: Fix bug 1173395 - Don't pass in non-ASCII pseudo filenames to difflib.

Run Details

10 of 10 new or added lines in 1 file covered. (100.0%)

7597 of 9408 relevant lines covered (80.75%)

0.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.84

/kuma/wiki/helpers.py

# -*- coding: utf-8 -*-
import difflib
import json
import re
import urllib
import urlparse

import jinja2
from pyquery import PyQuery as pq
from tidylib import tidy_document
from tower import ugettext as _

from django.conf import settings
from django.contrib.sites.models import Site
from django.core.serializers.json import DjangoJSONEncoder
from django.utils.html import conditional_escape

from constance import config
from jingo import register
from teamwork.shortcuts import build_policy_admin_links

from kuma.core.urlresolvers import reverse
from .constants import DIFF_WRAP_COLUMN
from .jobs import DocumentZoneStackJob
from .models import Document, memcache

register.function(build_policy_admin_links)


def compare_url(doc, from_id, to_id):
    return (
        reverse('wiki.compare_revisions', args=[doc.slug],
                locale=doc.locale)
        + '?' +
        urllib.urlencode({'from': from_id, 'to': to_id})
    )


# http://stackoverflow.com/q/774316/571420
def show_diff(seqm):
    """Unify operations between two compared strings
seqm is a difflib.SequenceMatcher instance whose a & b are strings"""
    lines = config.FEED_DIFF_CONTEXT_LINES
    full_output = []
    for opcode, a0, a1, b0, b1 in seqm.get_opcodes():
        if opcode == 'equal':
            full_output.append(seqm.a[a0:a1])
        elif opcode == 'insert':
            full_output.append("<ins>" + seqm.b[b0:b1] + "</ins>")
        elif opcode == 'delete':
            full_output.append("<del>" + seqm.a[a0:a1] + "</del>")
        elif opcode == 'replace':
            full_output.append("&nbsp;<del>" + seqm.a[a0:a1] + "</del>&nbsp;")
            full_output.append("&nbsp;<ins>" + seqm.b[b0:b1] + "</ins>&nbsp;")
        else:
            raise RuntimeError("unexpected opcode")
    output = []
    whitespace_change = False
    for piece in full_output:
        if '<ins>' in piece or '<del>' in piece:
            # a change
            if re.match('<(ins|del)>\W+</(ins|del)>', piece):
                # the change is whitespace,
                # ignore it and remove preceding context
                output = output[:-lines]
                whitespace_change = True
                continue
            else:
                output.append(piece)
        else:
            context_lines = piece.splitlines()
            if output == []:
                # first context only shows preceding lines for next change
                context = ['<p>...</p>'] + context_lines[-lines:]
            elif whitespace_change:
                # context shows preceding lines for next change
                context = ['<p>...</p>'] + context_lines[-lines:]
                whitespace_change = False
            else:
                # context shows subsequent lines
                # and preceding lines for next change
                context = (context_lines[:lines]
                           + ['<p>...</p>']
                           + context_lines[-lines:])
            output = output + context
    # remove extra context from the very end, unless its the only context
    if len(output) > lines + 1:  # context lines and the change line
        output = output[:-lines]
    return ''.join(output)


def _massage_diff_content(content):
    tidy_options = {
        'output-xhtml': 0,
        'force-output': 1,
    }
    try:
        content = tidy_document(content, options=tidy_options)
    except UnicodeDecodeError:
        # In case something happens in pytidylib we'll try again with
        # a proper encoding
        content = tidy_document(content.encode('utf-8'), options=tidy_options)
        tidied, errors = content
        content = tidied.decode('utf-8'), errors
    return content


@register.filter
def bugize_text(content):
    content = jinja2.escape(content)
    regex = re.compile('(bug)\s+#?(\d+)', re.IGNORECASE)
    content = regex.sub(
        jinja2.Markup('<a href="https://bugzilla.mozilla.org/'
                      'show_bug.cgi?id=\\2" '
                      'target="_blank">\\1 \\2</a>'),
        content)
    return content


@register.function
def format_comment(rev):
    """ Massages revision comment content after the fact """

    prev_rev = getattr(rev, 'previous_revision', None)
    if prev_rev is None:
        prev_rev = rev.get_previous()
    comment = bugize_text(rev.comment if rev.comment else "")

    # If a page move, say so
    if prev_rev and prev_rev.slug != rev.slug:
        comment += jinja2.Markup(
            '<span class="slug-change">'
            '<span>%s</span>'
            ' <i class="icon-long-arrow-right" aria-hidden="true"></i> '
            '<span>%s</span></span>') % (prev_rev.slug, rev.slug)

    return comment


@register.function
def revisions_unified_diff(from_revision, to_revision):
    if from_revision is None or to_revision is None:
        return "Diff is unavailable."
    fromfile = '[%s] #%s' % (from_revision.document.locale, from_revision.id)
    tofile = '[%s] #%s' % (to_revision.document.locale, to_revision.id)
    tidy_from, errors = _massage_diff_content(from_revision.content)
    tidy_to, errors = _massage_diff_content(to_revision.content)
    return u'\n'.join(difflib.unified_diff(
        tidy_from.splitlines(),
        tidy_to.splitlines(),
        fromfile=fromfile,
        tofile=tofile,
    ))


@register.function
def diff_table(content_from, content_to, prev_id, curr_id):
    """Creates an HTML diff of the passed in content_from and content_to."""
    tidy_from, errors = _massage_diff_content(content_from)
    tidy_to, errors = _massage_diff_content(content_to)
    html_diff = difflib.HtmlDiff(wrapcolumn=DIFF_WRAP_COLUMN)
    from_lines = tidy_from.splitlines()
    to_lines = tidy_to.splitlines()
    try:
        diff = html_diff.make_table(from_lines, to_lines,
                                    _("Revision %s") % prev_id,
                                    _("Revision %s") % curr_id,
                                    context=True,
                                    numlines=config.DIFF_CONTEXT_LINES)
    except RuntimeError:
        # some diffs hit a max recursion error
        message = _(u'There was an error generating the content.')
        diff = '<div class="warning"><p>%s</p></div>' % message
    return jinja2.Markup(diff)


@register.function
def diff_inline(content_from, content_to):
    tidy_from, errors = _massage_diff_content(content_from)
    tidy_to, errors = _massage_diff_content(content_to)
    sm = difflib.SequenceMatcher(None, tidy_from, tidy_to)
    diff = show_diff(sm)
    return jinja2.Markup(diff)


@register.function
def tag_diff_table(prev_tags, curr_tags, prev_id, curr_id):
    html_diff = difflib.HtmlDiff(wrapcolumn=DIFF_WRAP_COLUMN)
    prev_tag_lines = [prev_tags]
    curr_tag_lines = [curr_tags]

    diff = html_diff.make_table(prev_tag_lines, curr_tag_lines,
                                _("Revision %s") % prev_id,
                                _("Revision %s") % curr_id)

    # Simple formatting update: 784877
    diff = diff.replace('",', '"<br />').replace('<td', '<td valign="top"')
    return jinja2.Markup(diff)


@register.function
def colorize_diff(diff):
    # we're doing something horrible here because this will show up
    # in feed reader and other clients that don't load CSS files
    diff = diff.replace('<span class="diff_add"', '<span class="diff_add" '
                        'style="background-color: #afa; text-decoration: none;"')
    diff = diff.replace('<span class="diff_sub"', '<span class="diff_sub" '
                        'style="background-color: #faa; text-decoration: none;"')
    diff = diff.replace('<span class="diff_chg"', '<span class="diff_chg" '
                        'style="background-color: #fe0; text-decoration: none;"')
    return diff


@register.filter
def wiki_bleach(val):
    from kuma.wiki.models import Document
    return jinja2.Markup(Document.objects.clean_content(val))


@register.filter
def selector_content_find(document, selector):
    """
    Provided a selector, returns the relevant content from the document
    """
    summary = ''
    try:
        page = pq(document.rendered_html)
        summary = page.find(selector).text()
    except:
        pass
    return summary


def _recursive_escape(value, esc=conditional_escape):
    """
    Recursively escapes strings in an object.

    Traverses dict, list and tuples. These are the data structures supported
    by the JSON encoder.
    """
    if isinstance(value, dict):
        return type(value)((esc(k), _recursive_escape(v))
                           for (k, v) in value.iteritems())
    elif isinstance(value, (list, tuple)):
        return type(value)(_recursive_escape(v) for v in value)
    elif isinstance(value, basestring):
        return esc(value)
    elif isinstance(value, (int, long, float)) or value in (True, False, None):
        return value
    # We've exhausted all the types acceptable by the default JSON encoder.
    # Django's improved JSON encoder handles a few other types, all of which
    # are represented by strings. For these types, we apply JSON encoding
    # immediately and then escape the result.
    return esc(DjangoJSONEncoder().default(value))


@register.filter
def tojson(value):
    """
    Returns the JSON representation of the value.
    """
    try:
        # If value contains custom subclasses of int, str, datetime, etc.
        # arbitrary exceptions may be raised during escaping or serialization.
        result = json.dumps(_recursive_escape(value), cls=DjangoJSONEncoder)
    except Exception:
        return ''
    return jinja2.Markup(result)


@register.function
def document_zone_management_links(user, document):
    links = {'add': None, 'change': None}
    stack = DocumentZoneStackJob().get(document.pk)
    zone = (len(stack) > 0) and stack[0] or None

    # Enable "add" link if there is no zone for this document, or if there's a
    # zone but the document is not itself the root (ie. to add sub-zones).
    if ((not zone or zone.document != document) and
            user.has_perm('wiki.add_documentzone')):
        links['add'] = '%s?document=%s' % (
            reverse('admin:wiki_documentzone_add'), document.id)

    # Enable "change" link if there's a zone, and the user has permission.
    if zone and user.has_perm('wiki.change_documentzone'):
        links['change'] = reverse('admin:wiki_documentzone_change',
                                  args=(zone.id,))

    return links


@register.filter
def absolutify(url, site=None):
    """
    Joins a base ``Site`` URL with a URL path.

    If no site provided it gets the current site from Site.

    """
    if url.startswith('http'):
        return url

    if not site:
        site = Site.objects.get_current()

    parts = urlparse.urlsplit(url)

    scheme = 'https'
    netloc = site.domain
    path = parts.path
    query = parts.query
    fragment = parts.fragment

    if path == '':
        path = '/'

    return urlparse.urlunparse([scheme, netloc, path, None, query, fragment])


@register.function
@jinja2.contextfunction
def wiki_url(context, path):
    """
    Create a URL pointing to Kuma.
    Look for a wiki page in the current locale, or default to given path
    """
    default_locale = settings.WIKI_DEFAULT_LANGUAGE
    locale = getattr(context['request'], 'locale', default_locale)

    # let's first check if the cache is already filled
    url = memcache.get(u'wiki_url:%s:%s' % (locale, path))
    if url:
        # and return the URL right away if yes
        return url

    # shortcut for when the current locale is the default one (English)
    url = reverse('wiki.document', locale=default_locale, args=[path])

    if locale != default_locale:
        # in case the current request's locale is *not* the default, e.g. 'de'
        try:
            # check if there are any translated documents in the request's
            # locale of a document with the given path and the default locale
            translation = Document.objects.get(locale=locale,
                                               parent__slug=path,
                                               parent__locale=default_locale)

            # look if the document is actual just a redirect
            redirect_url = translation.redirect_url()
            if redirect_url is None:
                # if no, build the URL of the translation
                url = translation.get_absolute_url()
            else:
                # use the redirect URL instead
                url = redirect_url
        except Document.DoesNotExist:
            # otherwise use the already defined url to the English document
            pass

    # finally cache the reversed document URL for a bit
    memcache.set(u'wiki_url:%s:%s' % (locale, path), url, 60 * 5)
    return url

1	# -- coding: utf-8 --
2	import difflib	1✔
3	import json	1✔
4	import re	1✔
5	import urllib	1✔
6	import urlparse	1✔
7
8	import jinja2	1✔
9	from pyquery import PyQuery as pq	1✔
10	from tidylib import tidy_document	1✔
11	from tower import ugettext as _	1✔
12
13	from django.conf import settings	1✔
14	from django.contrib.sites.models import Site	1✔
15	from django.core.serializers.json import DjangoJSONEncoder	1✔
16	from django.utils.html import conditional_escape	1✔
17
18	from constance import config	1✔
19	from jingo import register	1✔
20	from teamwork.shortcuts import build_policy_admin_links	1✔
21
22	from kuma.core.urlresolvers import reverse	1✔
23	from .constants import DIFF_WRAP_COLUMN	1✔
24	from .jobs import DocumentZoneStackJob	1✔
25	from .models import Document, memcache	1✔
26
27	register.function(build_policy_admin_links)	1✔
28
29
30	def compare_url(doc, from_id, to_id):	1✔
31	return (	1✔
32	reverse('wiki.compare_revisions', args=[doc.slug],
33	locale=doc.locale)
34	+ '?' +
35	urllib.urlencode({'from': from_id, 'to': to_id})
36	)
37
38
39	# http://stackoverflow.com/q/774316/571420
40	def show_diff(seqm):	1✔
41	"""Unify operations between two compared strings
42	seqm is a difflib.SequenceMatcher instance whose a & b are strings"""
43	lines = config.FEED_DIFF_CONTEXT_LINES	×
44	full_output = []	×
45	for opcode, a0, a1, b0, b1 in seqm.get_opcodes():	×
46	if opcode == 'equal':	×
47	full_output.append(seqm.a[a0:a1])	×
48	elif opcode == 'insert':	×
49	full_output.append("<ins>" + seqm.b[b0:b1] + "</ins>")	×
50	elif opcode == 'delete':	×
51	full_output.append("<del>" + seqm.a[a0:a1] + "</del>")	×
52	elif opcode == 'replace':	×
53	full_output.append(" <del>" + seqm.a[a0:a1] + "</del> ")	×
54	full_output.append(" <ins>" + seqm.b[b0:b1] + "</ins> ")	×
55	else:
56	raise RuntimeError("unexpected opcode")	×
57	output = []	×
58	whitespace_change = False	×
59	for piece in full_output:	×
60	if '<ins>' in piece or '<del>' in piece:	×
61	# a change
62	if re.match('<(ins\|del)>\W+</(ins\|del)>', piece):	×
63	# the change is whitespace,
64	# ignore it and remove preceding context
65	output = output[:-lines]	×
66	whitespace_change = True	×
67	continue	×
68	else:
69	output.append(piece)	×
70	else:
71	context_lines = piece.splitlines()	×
72	if output == []:	×
73	# first context only shows preceding lines for next change
74	context = ['<p>...</p>'] + context_lines[-lines:]	×
75	elif whitespace_change:	×
76	# context shows preceding lines for next change
77	context = ['<p>...</p>'] + context_lines[-lines:]	×
78	whitespace_change = False	×
79	else:
80	# context shows subsequent lines
81	# and preceding lines for next change
82	context = (context_lines[:lines]	×
83	+ ['<p>...</p>']
84	+ context_lines[-lines:])
85	output = output + context	×
86	# remove extra context from the very end, unless its the only context
87	if len(output) > lines + 1: # context lines and the change line	×
88	output = output[:-lines]	×
89	return ''.join(output)	×
90
91
92	def _massage_diff_content(content):	1✔
93	tidy_options = {	1✔
94	'output-xhtml': 0,
95	'force-output': 1,
96	}
97	try:	1✔
98	content = tidy_document(content, options=tidy_options)	1✔
99	except UnicodeDecodeError:	×
100	# In case something happens in pytidylib we'll try again with
101	# a proper encoding
102	content = tidy_document(content.encode('utf-8'), options=tidy_options)	×
103	tidied, errors = content	×
104	content = tidied.decode('utf-8'), errors	×
105	return content	1✔
106
107
108	@register.filter	1✔
109	def bugize_text(content):
110	content = jinja2.escape(content)	1✔
111	regex = re.compile('(bug)\s+#?(\d+)', re.IGNORECASE)	1✔
112	content = regex.sub(	1✔
113	jinja2.Markup('<a href="https://bugzilla.mozilla.org/'
114	'show_bug.cgi?id=\\2" '
115	'target="_blank">\\1 \\2</a>'),
116	content)
117	return content	1✔
118
119
120	@register.function	1✔
121	def format_comment(rev):
122	""" Massages revision comment content after the fact """
123
124	prev_rev = getattr(rev, 'previous_revision', None)	1✔
125	if prev_rev is None:	1✔
126	prev_rev = rev.get_previous()	1✔
127	comment = bugize_text(rev.comment if rev.comment else "")	1✔
128
129	# If a page move, say so
130	if prev_rev and prev_rev.slug != rev.slug:	1✔
131	comment += jinja2.Markup(	×
132	'<span class="slug-change">'
133	'<span>%s</span>'
134	' <i class="icon-long-arrow-right" aria-hidden="true"></i> '
135	'<span>%s</span></span>') % (prev_rev.slug, rev.slug)
136
137	return comment	1✔
138
139
140	@register.function	1✔
141	def revisions_unified_diff(from_revision, to_revision):
142	if from_revision is None or to_revision is None:	1✔
143	return "Diff is unavailable."	1✔
144	fromfile = '[%s] #%s' % (from_revision.document.locale, from_revision.id)	1✔
145	tofile = '[%s] #%s' % (to_revision.document.locale, to_revision.id)	1✔
146	tidy_from, errors = _massage_diff_content(from_revision.content)	1✔
147	tidy_to, errors = _massage_diff_content(to_revision.content)	1✔
148	return u'\n'.join(difflib.unified_diff(	1✔
149	tidy_from.splitlines(),
150	tidy_to.splitlines(),
151	fromfile=fromfile,
152	tofile=tofile,
153	))
154
155
156	@register.function	1✔
157	def diff_table(content_from, content_to, prev_id, curr_id):
158	"""Creates an HTML diff of the passed in content_from and content_to."""
159	tidy_from, errors = _massage_diff_content(content_from)	1✔
160	tidy_to, errors = _massage_diff_content(content_to)	1✔
161	html_diff = difflib.HtmlDiff(wrapcolumn=DIFF_WRAP_COLUMN)	1✔
162	from_lines = tidy_from.splitlines()	1✔
163	to_lines = tidy_to.splitlines()	1✔
164	try:	1✔
165	diff = html_diff.make_table(from_lines, to_lines,	1✔
166	_("Revision %s") % prev_id,
167	_("Revision %s") % curr_id,
168	context=True,
169	numlines=config.DIFF_CONTEXT_LINES)
170	except RuntimeError:	×
171	# some diffs hit a max recursion error
172	message = _(u'There was an error generating the content.')	×
173	diff = '<div class="warning"><p>%s</p></div>' % message	×
174	return jinja2.Markup(diff)	1✔
175
176
177	@register.function	1✔
178	def diff_inline(content_from, content_to):
179	tidy_from, errors = _massage_diff_content(content_from)	×
180	tidy_to, errors = _massage_diff_content(content_to)	×
181	sm = difflib.SequenceMatcher(None, tidy_from, tidy_to)	×
182	diff = show_diff(sm)	×
183	return jinja2.Markup(diff)	×
184
185
186	@register.function	1✔
187	def tag_diff_table(prev_tags, curr_tags, prev_id, curr_id):
188	html_diff = difflib.HtmlDiff(wrapcolumn=DIFF_WRAP_COLUMN)	1✔
189	prev_tag_lines = [prev_tags]	1✔
190	curr_tag_lines = [curr_tags]	1✔
191
192	diff = html_diff.make_table(prev_tag_lines, curr_tag_lines,	1✔
193	_("Revision %s") % prev_id,
194	_("Revision %s") % curr_id)
195
196	# Simple formatting update: 784877
197	diff = diff.replace('",', '"<br />').replace('<td', '<td valign="top"')	1✔
198	return jinja2.Markup(diff)	1✔
199
200
201	@register.function	1✔
202	def colorize_diff(diff):
203	# we're doing something horrible here because this will show up
204	# in feed reader and other clients that don't load CSS files
205	diff = diff.replace('<span class="diff_add"', '<span class="diff_add" '	1✔
206	'style="background-color: #afa; text-decoration: none;"')
207	diff = diff.replace('<span class="diff_sub"', '<span class="diff_sub" '	1✔
208	'style="background-color: #faa; text-decoration: none;"')
209	diff = diff.replace('<span class="diff_chg"', '<span class="diff_chg" '	1✔
210	'style="background-color: #fe0; text-decoration: none;"')
211	return diff	1✔
212
213
214	@register.filter	1✔
215	def wiki_bleach(val):
216	from kuma.wiki.models import Document	×
217	return jinja2.Markup(Document.objects.clean_content(val))	×
218
219
220	@register.filter	1✔
221	def selector_content_find(document, selector):
222	"""
223	Provided a selector, returns the relevant content from the document
224	"""
225	summary = ''	×
226	try:	×
227	page = pq(document.rendered_html)	×
228	summary = page.find(selector).text()	×
229	except:	×
230	pass	×
231	return summary	×
232
233
234	def _recursive_escape(value, esc=conditional_escape):	1✔
235	"""
236	Recursively escapes strings in an object.
237
238	Traverses dict, list and tuples. These are the data structures supported
239	by the JSON encoder.
240	"""
241	if isinstance(value, dict):	1✔
242	return type(value)((esc(k), _recursive_escape(v))	1✔
243	for (k, v) in value.iteritems())
244	elif isinstance(value, (list, tuple)):	1✔
245	return type(value)(_recursive_escape(v) for v in value)	1✔
246	elif isinstance(value, basestring):	1✔
247	return esc(value)	1✔
248	elif isinstance(value, (int, long, float)) or value in (True, False, None):	1✔
249	return value	1✔
250	# We've exhausted all the types acceptable by the default JSON encoder.
251	# Django's improved JSON encoder handles a few other types, all of which
252	# are represented by strings. For these types, we apply JSON encoding
253	# immediately and then escape the result.
254	return esc(DjangoJSONEncoder().default(value))	×
255
256
257	@register.filter	1✔
258	def tojson(value):
259	"""
260	Returns the JSON representation of the value.
261	"""
262	try:	1✔
263	# If value contains custom subclasses of int, str, datetime, etc.
264	# arbitrary exceptions may be raised during escaping or serialization.
265	result = json.dumps(_recursive_escape(value), cls=DjangoJSONEncoder)	1✔
266	except Exception:	×
267	return ''	×
268	return jinja2.Markup(result)	1✔
269
270
271	@register.function	1✔
272	def document_zone_management_links(user, document):
273	links = {'add': None, 'change': None}	1✔
274	stack = DocumentZoneStackJob().get(document.pk)	1✔
275	zone = (len(stack) > 0) and stack[0] or None	1✔
276
277	# Enable "add" link if there is no zone for this document, or if there's a
278	# zone but the document is not itself the root (ie. to add sub-zones).
279	if ((not zone or zone.document != document) and	1✔
280	user.has_perm('wiki.add_documentzone')):
281	links['add'] = '%s?document=%s' % (	1✔
282	reverse('admin:wiki_documentzone_add'), document.id)
283
284	# Enable "change" link if there's a zone, and the user has permission.
285	if zone and user.has_perm('wiki.change_documentzone'):	1✔
286	links['change'] = reverse('admin:wiki_documentzone_change',	1✔
287	args=(zone.id,))
288
289	return links	1✔
290
291
292	@register.filter	1✔
293	def absolutify(url, site=None):	1✔
294	"""
295	Joins a base ``Site`` URL with a URL path.
296
297	If no site provided it gets the current site from Site.
298
299	"""
300	if url.startswith('http'):	1✔
301	return url	1✔
302
303	if not site:	1✔
304	site = Site.objects.get_current()	1✔
305
306	parts = urlparse.urlsplit(url)	1✔
307
308	scheme = 'https'	1✔
309	netloc = site.domain	1✔
310	path = parts.path	1✔
311	query = parts.query	1✔
312	fragment = parts.fragment	1✔
313
314	if path == '':	1✔
315	path = '/'	1✔
316
317	return urlparse.urlunparse([scheme, netloc, path, None, query, fragment])	1✔
318
319
320	@register.function	1✔
321	@jinja2.contextfunction	1✔
322	def wiki_url(context, path):
323	"""
324	Create a URL pointing to Kuma.
325	Look for a wiki page in the current locale, or default to given path
326	"""
327	default_locale = settings.WIKI_DEFAULT_LANGUAGE	1✔
328	locale = getattr(context['request'], 'locale', default_locale)	1✔
329
330	# let's first check if the cache is already filled
331	url = memcache.get(u'wiki_url:%s:%s' % (locale, path))	1✔
332	if url:	1✔
333	# and return the URL right away if yes
334	return url	1✔
335
336	# shortcut for when the current locale is the default one (English)
337	url = reverse('wiki.document', locale=default_locale, args=[path])	1✔
338
339	if locale != default_locale:	1✔
340	# in case the current request's locale is not the default, e.g. 'de'
341	try:	1✔
342	# check if there are any translated documents in the request's
343	# locale of a document with the given path and the default locale
344	translation = Document.objects.get(locale=locale,	1✔
345	parent__slug=path,
346	parent__locale=default_locale)
347
348	# look if the document is actual just a redirect
349	redirect_url = translation.redirect_url()	×
350	if redirect_url is None:	×
351	# if no, build the URL of the translation
352	url = translation.get_absolute_url()	×
353	else:
354	# use the redirect URL instead
355	url = redirect_url	×
356	except Document.DoesNotExist:	1✔
357	# otherwise use the already defined url to the English document
358	pass	1✔
359
360	# finally cache the reversed document URL for a bit
361	memcache.set(u'wiki_url:%s:%s' % (locale, path), url, 60 * 5)	1✔
362	return url	1✔

mozilla / kuma / 3998

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous