def search_pages_macro(macro, environ, **kwargs):
"""
A creole macro that lists wiki pages according to various criteria (tags only for now).
Usage: <<PageList tags=tag1,tag2,tag3>>
"""
from genshi import Markup
from ductus.resource.ductmodels import tag_value_attribute_validator
from ductus.index import search_pages
tags = kwargs.get("tags", '')
try:
parsed_tags = tags.split(',')
for tag in parsed_tags:
tag_value_attribute_validator(tag)
except Exception:
return Markup('<p>Invalid tag search</p>')
try:
pages = search_pages(tags=parsed_tags)
except Exception:
return Markup('<p>Search failed</p>')
html = ['<ul>']
for page in pages:
html.append('<li><a href="{0}">{1}</a></li>'.format(
page['path'], page['absolute_pagename']))
html.append('</ul>')
return Markup('<p class="search_results">' + '\n'.join(html) + '</p>')
def add_script(req,
filename,
mimetype='text/javascript',
charset='utf-8',
ie_if=None):
"""Add a reference to an external javascript file to the template.
If `filename` is a network-path reference (i.e. starts with a protocol
or `//`), the return value will not be modified. If `filename` is absolute
(i.e. starts with `/`), the generated link will be based off the
application root path. If it is relative, the link will be based off the
`/chrome/` path.
"""
scriptset = req.chrome.setdefault('scriptset', set())
if filename in scriptset:
return False # Already added that script
href = _chrome_resource_path(req, filename)
script = {
'href': href,
'type': mimetype,
'charset': charset,
'prefix': Markup('<!--[if %s]>' % ie_if) if ie_if else None,
'suffix': Markup('<![endif]-->') if ie_if else None
}
req.chrome.setdefault('scripts', []).append(script)
scriptset.add(filename)
def GET(self):
uri = URIRef(web.input()['uri'])
r = MediaResource(graph, uri)
size = r.getSize(sizes["screen"])
try:
created = photoCreated(graph, uri)
prettyDate = created.date().isoformat()
except ValueError:
prettyDate = "(unknown date)"
tmpl = loader.load("sharesingle.html")
stream = tmpl.generate(
title="photo",
prettyDate=prettyDate,
bestJqueryLink=networking.jqueryLink(
web.ctx.environ.get('HTTP_X_FORWARDED_FOR', '')),
featuredImg=Markup('<img src="%s" width="%s" height="%s"/>' %
(localSite(uri)+"?size=screen",
size[0], size[1])),
loginWidget=Markup(networking.getLoginBarSync(
web.ctx.environ.get('HTTP_COOKIE', ''))),
actionsAllowed=[],
otherSizeLinks=[],
link="l",
allowedToWriteMeta=False,
pageJson="",
)
return (''.join(serializer(stream))).encode('utf8')
def _on_httperror(self, event, req, res, code, **kwargs):
event.stop()
self.environ.request = req
self.environ.response = res
data = event.data.copy()
data["title"] = "Error"
data["traceback"] = Markup(data["traceback"])
data["description"] = Markup(data["description"] or u"")
response.body = self.render("error.html", **data)
return self.fire(response(res))
def render_stream(stream, method='auto', template_name=None):
"""Render the given stream to a unicode Markup string.
We substitute the standard XHTMLSerializer with our own
:class:`XHTMLPlusSerializer` which is (more) HTML5-aware.
:type stream: :class:`genshi.Stream`
:param stream: An iterable markup stream.
:param method: The serialization method for Genshi to use.
If given 'auto', the default value, we assume xhtml unless
a template name is given with an xml extension.
:param template_name: Optional template name which we use only to
guess what method to use, if one hasn't been explicitly provided.
:rtype: :class:`genshi.Markup`
:returns: A subclassed `unicode` object.
"""
if method == 'auto':
if template_name and template_name.endswith('.xml'):
method = 'xml'
else:
method = 'xhtml'
if method == 'xhtml':
method = XHTMLPlusSerializer
return Markup(stream.render(method=method, encoding=None))
def query(self, req, query='', attribute_handlers=None):
"""Return a sequence of (resource, tags) tuples matching a query.
Query syntax is described in tractags.query.
:param attribute_handlers: Register additional query attribute
handlers. See Query documentation for more
information.
"""
def realm_handler(_, node, context):
return query.match(node, [context.realm])
all_attribute_handlers = {
'realm': realm_handler,
}
all_attribute_handlers.update(attribute_handlers or {})
if re.search(
r'(expression|tagspace|tagspaces|operation|showheadings'
'|expression)=', query):
message = Markup(
'You seem to be using an old Tag query. '
'Try using the <a href="%s">new syntax</a> in your '
'<strong>ListTagged</strong> macro.', req.href('tags'))
add_warning(req, message)
query = Query(query, attribute_handlers=all_attribute_handlers)
query_tags = set(query.terms())
for provider in self.tag_providers:
for resource, tags in provider.get_tagged_resources(
req, query_tags):
if query(tags, context=resource):
yield resource, tags
def render_template(template_name, template_vals={}):
loader = TemplateLoader('theme/frontend')
template = loader.load(template_name)
template_vals['render'] = render_template
template_vals['Registry'] = Registry
stream = template.generate(**template_vals)
rendered = stream.render()
return Markup(rendered.decode('utf-8'))
def code(macro, environ, lang='text', linenos=False):
"""Macro for syntax highlighting using pygments."""
try:
lexer = get_lexer_by_name(lang)
except ClassNotFound:
return tag.div(_('No such language: {lang}').format(lang=lang),
class_='error')
formatter = HtmlFormatter(linenos=linenos == 'yes')
return Markup(highlight(macro.body, lexer, formatter))
def prevnext_nav(req, prev_label, next_label, up_label=None):
"""Add Previous/Up/Next navigation links.
:param req: a `Request` object
:param prev_label: the label to use for left (previous) link
:param up_label: the label to use for the middle (up) link
:param next_label: the label to use for right (next) link
"""
links = req.chrome['links']
prev_link = next_link = None
if not any(lnk in links
for lnk in ('prev', 'up', 'next')): # Short circuit
return
if 'prev' in links:
prev = links['prev'][0]
prev_link = tag.a(prev_label,
href=prev['href'],
title=prev['title'],
class_='prev')
add_ctxtnav(
req,
tag.span(Markup('← '),
prev_link or prev_label,
class_='missing' if not prev_link else None))
if up_label and 'up' in links:
up = links['up'][0]
add_ctxtnav(req, tag.a(up_label, href=up['href'], title=up['title']))
if 'next' in links:
next_ = links['next'][0]
next_link = tag.a(next_label,
href=next_['href'],
title=next_['title'],
class_='next')
add_ctxtnav(
req,
tag.span(next_link or next_label,
Markup(' →'),
class_='missing' if not next_link else None))
def set_mixed_value(self, override, attrs, stream, node):
"""
For output nodes that may either take a 'value=""' or encode
their value in nested content. Node value will be passed
along as unescaped markup if child nodes are generated!
"""
if attrs.get(H_VALUE, None) is None:
stream = self.set_stream_value(stream, Markup(node))
else:
attrs = self.set_simple_value(override, attrs, node)
return stream, attrs
def global_resources():
""" Returns a rendered Moksha Global Resource Widget.
This widget contains all of the resources and widgets on the
`moksha.global` entry-point. To use it, simply do this at the bottom of
your master template::
${tmpl_context.moksha_global_resources()}
"""
import tg
from moksha.api.widgets.global_resources import global_resources as globs
if tg.config.default_renderer == 'genshi':
# There's Got To Be A Better Way!
from genshi import unescape, Markup
return Markup(unescape(Markup(globs)))
elif tg.config.default_renderer == 'mako':
return globs()
else:
# If this gets called, and explodes, then you need to add support
# for your templating engine here.
return globs()
def global_resources():
""" Returns a rendered Moksha Global Resource Widget.
This widget contains all of the resources and widgets on the
`moksha.global` entry-point. To use it, simply do this at the bottom of
your master template::
${tmpl_context.moksha_global_resources()}
:Warning: It must be called at the *bottom* of your template. It must be
the last thing that executes. It won't inject resources for
widgets that get displayed *after* this function is called.
Often, you want moksha's global resources to appear on every page.
You can override the BaseController of your app in ``yourapp.lib.base`` and
set the following inside the __call__ method::
from moksha.wsgi.ext.turbogears import global_resources
tmpl_context.moksha_global_resources = global_resources
"""
import tg
from moksha.wsgi.widgets.api.global_resources import global_resources as globs
globs = globs(config=tg.config, request=tg.request, base_url=tg.url('/'))
if tg.config.default_renderer == 'genshi':
# There's Got To Be A Better Way!
# TODO -- consider webhelpers.literal
from genshi import unescape, Markup
return Markup(unescape(Markup(globs.display())))
elif tg.config.default_renderer == 'mako':
return globs.display()
else:
# If this gets called, and explodes, then you need to add support
# for your templating engine here.
return globs.display()
def dados_adicionais_libreoffice(NFe):
da = ''
if hasattr(NFe.infNFe, 'infAdic'):
if hasattr(NFe.infNFe.infAdic, 'infAdFisco'):
da = NFe.infNFe.infAdic.infAdFisco.text.replace(
'| ', '<text:line-break/>')
if hasattr(NFe.infNFe.infAdic, 'infCpl'):
if len(da) > 0:
da += '<text:line-break/>'
da += NFe.infNFe.infAdic.infCpl.text.replace(
'| ', '<text:line-break/>')
return Markup(da)
def highlight(text, mime=None, lang=None, linenos=False, title=""):
formatter = HTMLFormatter(cssclass="code",
linenos=linenos,
full=True,
title=title)
try:
if mime:
lexer = pygments.lexers.get_lexer_for_mimetype(mime)
elif lang:
lexer = pygments.lexers.get_lexer_by_name(lang)
else:
lexer = pygments.lexers.guess_lexer(text)
except pygments.util.ClassNotFound:
return tag.pre(text)
return Markup(pygments.highlight(text, lexer, formatter))
def expand_macro(self, formatter, name, content):
citelist = getattr(formatter, CITELIST, [])
bibdb = getattr(formatter, BIBDB, {})
page = WikiPage(self.env, 'BibTex')
if page.exists:
if '{{{' in page.text and '}}}' in page.text:
tmp = re.compile('{{{|}}}', 2).split(page.text)
bibdb.update(extract_entries(tmp[1]))
setattr(formatter, BIBDB, bibdb)
str = ''
for k in citelist:
if bibdb.has_key(k) == False:
str += 'No entry ' + k + ' found.\n'
if str != '':
raise TracError('[[' + str + ']]')
l = []
for k in citelist:
content = []
for bibkey in BIBTEX_KEYS:
if bibdb[k].has_key(bibkey):
content.append(tag.span(Markup(bibdb[k][bibkey] + ', ')))
if bibdb[k].has_key('url') == False:
l.append(
tag.li(tag.a(name=k),
tag.a(href='#cite_%s' % k)('^'), content))
else:
url = bibdb[k]['url']
l.append(
tag.li(tag.a(name=k),
tag.a(href='#cite_%s' % k)('^'), content, tag.br(),
tag.a(href=url)(url)))
ol = tag.ol(*l)
tags = []
tags.append(tag.h1(id='References')('References'))
tags.append(ol)
return tag.div(id='References')(*tags)
def get_navigation_items(self, req):
yield 'mainnav', 'tracker', Markup('<a href="%s">Tracker</a>' %
(self.env.href.tracker()))
def render_template(self,
req,
filename,
data,
content_type=None,
fragment=False,
method=None):
"""Render the `filename` using the `data` for the context.
The `content_type` argument is used to choose the kind of template
used (`NewTextTemplate` if `'text/plain'`, `MarkupTemplate`
otherwise), and tweak the rendering process. Doctype for `'text/html'`
can be specified by setting the `html_doctype` attribute (default
is `XHTML_STRICT`)
The rendering `method` (xml, xhtml or text) may be specified and is
inferred from the `content_type` if not specified.
When `fragment` is specified, the (filtered) Genshi stream is
returned.
"""
if content_type is None:
content_type = 'text/html'
if method is None:
method = {
'text/html': 'xhtml',
'text/plain': 'text'
}.get(content_type, 'xml')
if method == "xhtml":
# Retrieve post-redirect messages saved in session
for type_ in ['warnings', 'notices']:
try:
for i in itertools.count():
message = Markup(
req.session.pop('chrome.%s.%d' % (type_, i)))
if message not in req.chrome[type_]:
req.chrome[type_].append(message)
except KeyError:
pass
template = self.load_template(filename, method=method)
data = self.populate_data(req, data)
data['chrome']['content_type'] = content_type
stream = template.generate(**data)
# Filter through ITemplateStreamFilter plugins
if self.stream_filters:
stream |= self._filter_stream(req, method, filename, stream, data)
if fragment:
return stream
if method == 'text':
buffer = StringIO()
stream.render('text', out=buffer, encoding='utf-8')
return buffer.getvalue()
doctype = None
if content_type == 'text/html':
doctype = self.html_doctype
if req.form_token:
stream |= self._add_form_token(req.form_token)
if not int(req.session.get('accesskeys', 0)):
stream |= self._strip_accesskeys
links = req.chrome.get('links')
scripts = req.chrome.get('scripts')
script_data = req.chrome.get('script_data')
req.chrome['links'] = {}
req.chrome['scripts'] = []
req.chrome['script_data'] = {}
data.setdefault('chrome', {}).update({
'late_links':
req.chrome['links'],
'late_scripts':
req.chrome['scripts'],
'late_script_data':
req.chrome['script_data'],
})
try:
buffer = StringIO()
stream.render(method,
doctype=doctype,
out=buffer,
encoding='utf-8')
return buffer.getvalue().translate(_translate_nop,
_invalid_control_chars)
except Exception as e:
# restore what may be needed by the error template
req.chrome['links'] = links
req.chrome['scripts'] = scripts
req.chrome['script_data'] = script_data
# give some hints when hitting a Genshi unicode error
if isinstance(e, UnicodeError):
pos = self._stream_location(stream)
if pos:
location = "'%s', line %s, char %s" % pos
else:
location = _("(unknown template location)")
raise TracError(
_(
"Genshi %(error)s error while rendering "
"template %(location)s",
error=e.__class__.__name__,
location=location))
raise
def escape(text, quotes=True):
if text:
return _escape(text, quotes=quotes)
else:
return Markup(u'')
def informacoes_adicionais_formatadas(det):
formatado = str(det.infAdProd).replace('|', '<text:line-break/>')
return Markup(formatado)
def render(self,
context,
mimetype,
content,
filename=None,
url=None,
annotations=None,
force_source=False):
"""Render an XHTML preview of the given `content`.
`content` is the same as an `IHTMLPreviewRenderer.render`'s
`content` argument.
The specified `mimetype` will be used to select the most appropriate
`IHTMLPreviewRenderer` implementation available for this MIME type.
If not given, the MIME type will be infered from the filename or the
content.
Return a string containing the XHTML text.
When rendering with an `IHTMLPreviewRenderer` fails, a warning is added
to the request associated with the context (if any), unless the
`disable_warnings` hint is set to `True`.
"""
if not content:
return ''
if not isinstance(context, RenderingContext):
raise TypeError("RenderingContext expected (since 0.11)")
# Ensure we have a MIME type for this content
full_mimetype = mimetype
if not full_mimetype:
if hasattr(content, 'read'):
content = content.read(self.max_preview_size)
full_mimetype = self.get_mimetype(filename, content)
if full_mimetype:
mimetype = ct_mimetype(full_mimetype) # split off charset
else:
mimetype = full_mimetype = 'text/plain' # fallback if not binary
# Determine candidate `IHTMLPreviewRenderer`s
candidates = []
for renderer in self.renderers:
qr = renderer.get_quality_ratio(mimetype)
if qr > 0:
candidates.append((qr, renderer))
candidates.sort(lambda x, y: cmp(y[0], x[0]))
# Wrap file-like object so that it can be read multiple times
if hasattr(content, 'read'):
content = Content(content, self.max_preview_size)
# First candidate which renders successfully wins.
# Also, we don't want to expand tabs more than once.
expanded_content = None
for qr, renderer in candidates:
if force_source and not getattr(renderer, 'returns_source', False):
continue # skip non-source renderers in force_source mode
if isinstance(content, Content):
content.reset()
try:
ann_names = ', '.join(annotations) if annotations else \
'no annotations'
self.log.debug('Trying to render HTML preview using %s [%s]',
renderer.__class__.__name__, ann_names)
# check if we need to perform a tab expansion
rendered_content = content
if getattr(renderer, 'expand_tabs', False):
if expanded_content is None:
content = content_to_unicode(self.env, content,
full_mimetype)
expanded_content = content.expandtabs(self.tab_width)
rendered_content = expanded_content
result = renderer.render(context, full_mimetype,
rendered_content, filename, url)
if not result:
continue
if not (force_source
or getattr(renderer, 'returns_source', False)):
# Direct rendering of content
if isinstance(result, basestring):
if not isinstance(result, unicode):
result = to_unicode(result)
return Markup(to_unicode(result))
elif isinstance(result, Fragment):
return result.generate()
else:
return result
# Render content as source code
if annotations:
marks = context.req.args.get('marks') if context.req \
else None
if marks:
context.set_hints(marks=marks)
return self._render_source(context, result, annotations)
else:
if isinstance(result, list):
result = Markup('\n').join(result)
return tag.div(class_='code')(tag.pre(result)).generate()
except Exception as e:
self.log.warning('HTML preview using %s failed: %s',
renderer.__class__.__name__,
exception_to_unicode(e, traceback=True))
if context.req and not context.get_hint('disable_warnings'):
from trac.web.chrome import add_warning
add_warning(
context.req,
_("HTML preview using %(renderer)s failed (%(err)s)",
renderer=renderer.__class__.__name__,
err=exception_to_unicode(e)))
def comment(match, environ):
return Markup()
def expand_macro(self, formatter, name, content):
add_stylesheet(formatter.req, 'dirclass/css/dirclass.css')
return Markup('<div class="rtl">')
def _process_revtree(self, req):
"""Handle revtree generation requests"""
tracrepos = self.env.get_repository()
youngest = int(tracrepos.get_youngest_rev())
oldest = max(self.oldest, int(tracrepos.get_oldest_rev()))
if self.abstime:
timebase = int(time.time())
else:
timebase = to_timestamp(tracrepos.get_changeset(youngest).date)
revstore = RevtreeStore(self.env, req.authname, \
(oldest, youngest),
timebase, self.style)
if req.args.has_key('reset') and req.args['reset']:
revstore.clear(req.session)
else:
revstore.load(req.session)
if req.args:
revstore.populate(req.args)
revstore.compute_range(timebase)
data = revstore.get_values()
try:
if not revstore.can_be_rendered():
raise EmptyRangeError
repos = Repository(self.env, req.authname)
repos.build(self.bcre, revstore.revrange, revstore.timerange)
(branches, authors) = \
self._select_parameters(repos, req, revstore)
svgrevtree = self.rt.get_revtree(repos, req)
if revstore['branch']:
sbranches = [revstore['branch']]
sbranches.extend(
filter(lambda t: t not in sbranches, self.trunks))
else:
sbranches = None
sauthors = revstore['author'] and [revstore['author']] or None
if revstore['showdel']:
hidetermbranch = False
else:
hidetermbranch = True
svgrevtree.create(req,
revisions=revstore.revrange,
branches=sbranches,
authors=sauthors,
hidetermbranch=hidetermbranch,
style=revstore['style'])
svgrevtree.build()
svgrevtree.render(self.scale * 0.6)
style = req.href.chrome('revtree/css/revtree.css')
svgstyle = '<?xml-stylesheet href="%s" type="text/css"?>' % style
data.update({
'svg': Markup(unicode(str(svgrevtree), 'utf-8')),
'svgstyle': Markup(svgstyle)
})
# create and order the drop-down list content, starting with the
# global values
branches = repos.branches().keys()
authors = repos.authors()
# save the user parameters only if the tree can be rendered
revstore.save(req.session)
except EmptyRangeError:
data.update({'errormsg': \
"Selected filters cannot render a revision tree"})
# restore default parameters
repos = Repository(self.env, req.authname)
repos.build(self.bcre, revrange=(oldest, youngest))
branches = repos.branches().keys()
authors = repos.authors()
revrange = repos.revision_range()
revisions = self._get_ui_revisions((oldest, youngest), revrange)
branches.sort()
# prepend the trunks to the selected branches
for b in filter(lambda t: t not in branches, self.trunks):
branches.insert(0, b)
branches = filter(None, branches)
branches.insert(0, '')
authors.sort()
authors = filter(None, authors)
authors.insert(0, '')
dauthors = [dict(name=a, label=a or 'All') for a in authors]
dbranches = [dict(name=b, label=b or 'All') for b in branches]
data.update({
'title': 'Revision Tree',
'periods': self._get_periods(),
'revmin': str(revrange[0]),
'revmax': str(revrange[1]),
'revisions': revisions,
'branches': dbranches,
'authors': dauthors
})
# add javascript for AJAX tooltips
add_script(req, 'revtree/js/svgtip.js')
# add custom stylesheet
add_stylesheet(req, 'revtree/css/revtree.css')
return 'revtree.html', {'rt': data}, 'application/xhtml+xml'
def striptags(x):
if isinstance(x, (Stream, Markup)):
return Markup(x).striptags()
else:
return x
def populate_data(self, req, data):
d = self._default_context_data.copy()
d['trac'] = {
'version': VERSION,
'homepage': 'http://trac.edgewall.org/', # FIXME: use setup data
}
href = req and req.href
abs_href = req.abs_href if req else self.env.abs_href
admin_href = None
if self.env.project_admin_trac_url == '.':
admin_href = href
elif self.env.project_admin_trac_url:
admin_href = Href(self.env.project_admin_trac_url)
d['project'] = {
'name': self.env.project_name,
'descr': self.env.project_description,
'url': self.env.project_url,
'admin': self.env.project_admin,
'admin_href': admin_href,
'admin_trac_url': self.env.project_admin_trac_url,
}
footer = self.env.project_footer
d['chrome'] = {
'footer': Markup(footer and translation.gettext(footer))
}
if req:
d['chrome'].update(req.chrome)
else:
d['chrome'].update({
'htdocs_location': self.htdocs_location,
'logo': self.get_logo_data(self.env.abs_href),
})
try:
show_email_addresses = (self.show_email_addresses or not req
or 'EMAIL_VIEW' in req.perm)
except Exception as e:
# simply log the exception here, as we might already be rendering
# the error page
self.log.error("Error during check of EMAIL_VIEW: %s",
exception_to_unicode(e))
show_email_addresses = False
def pretty_dateinfo(date, format=None, dateonly=False):
if not date:
return ''
if format == 'date':
absolute = user_time(req, format_date, date)
else:
absolute = user_time(req, format_datetime, date)
now = datetime.datetime.now(localtz)
relative = pretty_timedelta(date, now)
if not format:
format = req.session.get('dateinfo',
self.default_dateinfo_format)
in_or_ago = _("in %(relative)s", relative=relative) \
if date > now else \
_("%(relative)s ago", relative=relative)
if format == 'relative':
label = in_or_ago if not dateonly else relative
title = absolute
else:
if dateonly:
label = absolute
elif req.lc_time == 'iso8601':
label = _("at %(iso8601)s", iso8601=absolute)
else:
label = _("on %(date)s at %(time)s",
date=user_time(req, format_date, date),
time=user_time(req, format_time, date))
title = in_or_ago
return tag.span(label, title=title)
def dateinfo(date):
return pretty_dateinfo(date, format='relative', dateonly=True)
def get_rel_url(resource, **kwargs):
return get_resource_url(self.env, resource, href, **kwargs)
def get_abs_url(resource, **kwargs):
return get_resource_url(self.env, resource, abs_href, **kwargs)
d.update({
'context':
web_context(req) if req else None,
'Resource':
Resource,
'url_of':
get_rel_url,
'abs_url_of':
get_abs_url,
'name_of':
partial(get_resource_name, self.env),
'shortname_of':
partial(get_resource_shortname, self.env),
'summary_of':
partial(get_resource_summary, self.env),
'req':
req,
'abs_href':
abs_href,
'href':
href,
'perm':
req and req.perm,
'authname':
req.authname if req else '<trac>',
'locale':
req and req.locale,
'show_email_addresses':
show_email_addresses,
'show_ip_addresses':
self.show_ip_addresses,
'authorinfo':
partial(self.authorinfo, req),
'authorinfo_short':
self.authorinfo_short,
'format_author':
partial(self.format_author, req),
'format_emails':
self.format_emails,
'get_systeminfo':
self.env.get_systeminfo,
'captioned_button':
partial(presentation.captioned_button, req),
# Date/time formatting
'dateinfo':
dateinfo,
'pretty_dateinfo':
pretty_dateinfo,
'format_datetime':
partial(user_time, req, format_datetime),
'format_date':
partial(user_time, req, format_date),
'format_time':
partial(user_time, req, format_time),
'fromtimestamp':
partial(datetime.datetime.fromtimestamp, tz=req and req.tz),
'from_utimestamp':
from_utimestamp,
# Wiki-formatting functions
'wiki_to':
partial(format_to, self.env),
'wiki_to_html':
partial(format_to_html, self.env),
'wiki_to_oneliner':
partial(format_to_oneliner, self.env),
})
# Finally merge in the page-specific data
d.update(data)
return d
def renderPage(graph, topic, foafUser, cookie):
isVideo = {}
photos = photosWithTopic(graph, {'topic': topic}, isVideo=isVideo)
filtered = starFilter(graph, 'only', foafUser, photos)
if filtered:
photos = filtered
tmpl = loader.load("story.html")
rows = []
knownFacts = set()
commentJs = '1'
for photo in photos:
if not access.viewable(graph, photo, foafUser):
log.debug("story %s NeedsMoreAccess because %s can't view %s",
topic, foafUser, photo)
raise access.NeedsMoreAccess()
try:
date = photoCreated(graph, photo).date()
except ValueError:
date = None
else:
if not rows or rows[-1]['date'] != date:
rows.append(dict(type='date', date=date))
facts = json.loads(syncServiceCall('facts', photo, foafUser))
factLines = [
l['line'] for l in facts['factLines']
if not l['line'].startswith("Picture taken ")
]
factLines = [l for l in factLines if l not in knownFacts]
knownFacts.update(factLines)
commentHtml = syncServiceCall('comments',
photo,
foafUser,
js=commentJs)
if commentJs == '1':
commentJs = '0'
rows.append(
dict(
type='pic',
date=date,
uri=photo,
# more stable than the row num as pics get added and removed:
anchor=hashlib.md5(photo).hexdigest()[:8],
factLines=factLines,
isVideo=isVideo.get(photo, False),
commentHtml=Markup(commentHtml),
desc=graph.value(photo, RDFS.comment),
))
accessControl = pystache.render(
open("template/aclwidget.mustache").read(),
access.accessControlWidget(graph, foafUser, topic))
stream = tmpl.generate(
rows=rows,
title=graph.value(topic, RDFS.label, any=True),
localSite=localSite,
loginBar=Markup(networking.getLoginBarSync(cookie)),
accessControl=Markup(accessControl),
dateRange=findDateRange(graph, photos),
sizeAttrs=lambda uri, sizeName: sizeAttrs(graph, foafUser, uri,
sizeName),
)
return (''.join(serializer(stream))).encode('utf8')
def expand_macro(self, formatter, name, content):
add_stylesheet(formatter.req, 'newsflash/css/newsflash.css')
return Markup('<div class="newsflash">')
def expand_macro(self, formatter, name, content):
return Markup('</div>')
def diff_blocks(fromlines,
tolines,
context=None,
tabwidth=8,
ignore_blank_lines=0,
ignore_case=0,
ignore_space_changes=0):
"""Return an array that is adequate for adding to the data dictionary
See `get_filtered_hunks` for the parameter descriptions.
See also the diff_div.html template.
"""
type_map = {
'replace': 'mod',
'delete': 'rem',
'insert': 'add',
'equal': 'unmod'
}
space_re = re.compile(' ( +)|^ ')
def htmlify(match):
div, mod = divmod(len(match.group(0)), 2)
return div * ' ' + mod * ' '
def markup_intraline_changes(opcodes):
for tag, i1, i2, j1, j2 in opcodes:
if tag == 'replace' and i2 - i1 == j2 - j1:
for i in range(i2 - i1):
fromline, toline = fromlines[i1 + i], tolines[j1 + i]
(start, end) = get_change_extent(fromline, toline)
if start != 0 or end != 0:
last = end + len(fromline)
fromlines[i1 + i] = (fromline[:start] + '\0' +
fromline[start:last] + '\1' +
fromline[last:])
last = end + len(toline)
tolines[j1 + i] = (toline[:start] + '\0' +
toline[start:last] + '\1' +
toline[last:])
yield tag, i1, i2, j1, j2
changes = []
for group in get_filtered_hunks(fromlines, tolines, context,
ignore_blank_lines, ignore_case,
ignore_space_changes):
blocks = []
last_tag = None
for tag, i1, i2, j1, j2 in markup_intraline_changes(group):
if tag != last_tag:
blocks.append({
'type': type_map[tag],
'base': {
'offset': i1,
'lines': []
},
'changed': {
'offset': j1,
'lines': []
}
})
if tag == 'equal':
for line in fromlines[i1:i2]:
line = line.expandtabs(tabwidth)
line = space_re.sub(htmlify, escape(line, quotes=False))
blocks[-1]['base']['lines'].append(Markup(unicode(line)))
for line in tolines[j1:j2]:
line = line.expandtabs(tabwidth)
line = space_re.sub(htmlify, escape(line, quotes=False))
blocks[-1]['changed']['lines'].append(Markup(
unicode(line)))
else:
if tag in ('replace', 'delete'):
for line in fromlines[i1:i2]:
line = expandtabs(line, tabwidth, '\0\1')
line = escape(line, quotes=False)
line = '<del>'.join([
space_re.sub(htmlify, seg)
for seg in line.split('\0')
])
line = line.replace('\1', '</del>')
blocks[-1]['base']['lines'].append(
Markup(unicode(line)))
if tag in ('replace', 'insert'):
for line in tolines[j1:j2]:
line = expandtabs(line, tabwidth, '\0\1')
line = escape(line, quotes=False)
line = '<ins>'.join([
space_re.sub(htmlify, seg)
for seg in line.split('\0')
])
line = line.replace('\1', '</ins>')
blocks[-1]['changed']['lines'].append(
Markup(unicode(line)))
changes.append(blocks)
return changes
def expand_macro(self, formatter, name, content):
env = formatter.env
req = formatter.req
if not 'VOTE_VIEW' in req.perm:
return
# Simplify function calls.
format_author = partial(Chrome(self.env).format_author, req)
if not content:
args = []
compact = None
kw = {}
top = 5
else:
args, kw = parse_args(content)
compact = 'compact' in args and True
top = as_int(kw.get('top'), 5, min=0)
if name == 'LastVoted':
lst = tag.ul()
for i in self.get_votes(req, top=top):
resource = Resource(i[0], i[1])
# Anotate who and when.
voted = (
'by %s at %s' %
(format_author(i[3]), format_datetime(to_datetime(i[4]))))
lst(
tag.li(
tag.a(get_resource_description(
env, resource, compact and 'compact' or 'default'),
href=get_resource_url(env, resource,
formatter.href),
title=(compact and '%+i %s' % (i[2], voted)
or None)),
(not compact and Markup(' %s %s' %
(tag.b('%+i' % i[2]), voted))
or '')))
return lst
elif name == 'TopVoted':
realm = kw.get('realm')
lst = tag.ul()
for i in self.get_top_voted(req, realm=realm, top=top):
if 'up-only' in args and i[2] < 1:
break
resource = Resource(i[0], i[1])
lst(
tag.li(
tag.a(get_resource_description(
env, resource, compact and 'compact' or 'default'),
href=get_resource_url(env, resource,
formatter.href),
title=(compact and '%+i' % i[2] or None)),
(not compact and ' (%+i)' % i[2] or '')))
return lst
elif name == 'VoteList':
lst = tag.ul()
resource = resource_from_path(env, req.path_info)
for i in self.get_votes(req, resource, top=top):
vote = ('at %s' % format_datetime(to_datetime(i[4])))
lst(
tag.li(compact and format_author(i[3]) or Markup(
u'%s by %s %s' %
(tag.b('%+i' % i[2]), tag(format_author(i[3])), vote)),
title=(compact and '%+i %s' % (i[2], vote)
or None)))
return lst
