def expand_macro(self, formatter, name, content):
from trac.wiki.formatter import system_message
content = content.strip() if content else ''
name_filter = content.strip('*')
def get_macro_descr():
for macro_provider in formatter.wiki.macro_providers:
names = list(macro_provider.get_macros() or [])
if name_filter and not any(
name.startswith(name_filter) for name in names):
continue
try:
name_descriptions = [
(name, macro_provider.get_macro_description(name))
for name in names
]
except Exception as e:
yield system_message(
_("Error: Can't get description for macro %(name)s",
name=names[0]), e), names
else:
for descr, pairs in groupby(name_descriptions,
key=lambda p: p[1]):
if descr:
if isinstance(descr, (tuple, list)):
descr = dgettext(descr[0],
to_unicode(descr[1])) \
if descr[1] else ''
else:
descr = to_unicode(descr) or ''
if content == '*':
descr = format_to_oneliner(self.env,
formatter.context,
descr,
shorten=True)
else:
descr = format_to_html(self.env,
formatter.context,
descr)
yield descr, [name for name, descr in pairs]
return tag.div(class_='trac-macrolist')(
(tag.h3(tag.code('[[', names[0], ']]'), id='%s-macro' % names[0]),
len(names) > 1 and tag.p(
tag.strong(_("Aliases:")),
[tag.code(' [[', alias, ']]')
for alias in names[1:]]) or None,
description or tag.em(_("Sorry, no documentation found")))
for description, names in sorted(get_macro_descr(),
key=lambda item: item[1][0]))
def expand_macro(self, formatter, name, content):
args, kw = parse_args(content)
prefix = args[0].strip() if args else None
limit = _arg_as_int(args[1].strip(), min=1) if len(args) > 1 else None
group = kw.get('group', 'date')
sql = """SELECT name, max(version) AS max_version,
max(time) AS max_time FROM wiki"""
args = []
if prefix:
with self.env.db_query as db:
sql += " WHERE name %s" % db.prefix_match()
args.append(db.prefix_match_value(prefix))
sql += " GROUP BY name ORDER BY max_time DESC"
if limit:
sql += " LIMIT %s"
args.append(limit)
entries_per_date = []
prevdate = None
for name, version, ts in self.env.db_query(sql, args):
if 'WIKI_VIEW' not in formatter.perm('wiki', name, version):
continue
req = formatter.req
date = user_time(req, format_date, from_utimestamp(ts))
if date != prevdate:
prevdate = date
entries_per_date.append((date, []))
version = int(version)
diff_href = None
if version > 1:
diff_href = formatter.href.wiki(name, action='diff',
version=version)
page_name = formatter.wiki.format_page_name(name)
entries_per_date[-1][1].append((page_name, name, version,
diff_href))
items_per_date = (
(date, (tag.li(tag.a(page, href=formatter.href.wiki(name)),
tag.small(' (', tag.a(_("diff"), href=diff_href),
')') if diff_href else None,
'\n')
for page, name, version, diff_href in entries))
for date, entries in entries_per_date)
if group == 'date':
out = ((tag.h3(date, class_='section'), tag.ul(entries))
for date, entries in items_per_date)
else:
out = tag.ul(entries for date, entries in items_per_date)
return tag.div(out, class_="wikipage")
def expand_macro(self, formatter, name, content):
from trac.config import ConfigSection, Option
args, kw = parse_args(content)
filters = {}
for name, index in (('section', 0), ('option', 1)):
pattern = kw.get(name, '').strip()
if pattern:
filters[name] = fnmatch.translate(pattern)
continue
prefix = args[index].strip() if index < len(args) else ''
if prefix:
filters[name] = re.escape(prefix)
has_option_filter = 'option' in filters
for name in ('section', 'option'):
filters[name] = re.compile(filters[name], re.IGNORECASE).match \
if name in filters \
else lambda v: True
section_filter = filters['section']
option_filter = filters['option']
section_registry = ConfigSection.get_registry(self.compmgr)
option_registry = Option.get_registry(self.compmgr)
options = {}
for (section, key), option in option_registry.iteritems():
if section_filter(section) and option_filter(key):
options.setdefault(section, {})[key] = option
if not has_option_filter:
for section in section_registry:
if section_filter(section):
options.setdefault(section, {})
for section in options:
options[section] = sorted(options[section].itervalues(),
key=lambda option: option.name)
sections = [(section, section_registry[section].doc
if section in section_registry else '')
for section in sorted(options)]
def default_cell(option):
default = option.default
if default is not None and default != '':
return tag.td(tag.code(option.dumps(default)),
class_='default')
else:
return tag.td(_("(no default)"), class_='nodefault')
def options_table(section, options):
if options:
return tag.table(class_='wiki')(tag.tbody(
tag.tr(tag.td(
tag.a(tag.code(option.name),
class_='tracini-option',
href='#%s-%s-option' % (section, option.name))),
tag.td(
format_to_html(self.env, formatter.context,
option.doc)),
default_cell(option),
id='%s-%s-option' % (section, option.name),
class_='odd' if idx % 2 else 'even')
for idx, option in enumerate(options)))
return tag.div(class_='tracini')(
(tag.h3(tag.code('[%s]' % section), id='%s-section' % section),
format_to_html(self.env, formatter.context, section_doc),
options_table(section, options.get(section)))
for section, section_doc in sections)
