def get_urlmap(cls):
cls._endpoint_map = {}
urls = []
for comp in ctx.get_implementations(cls, instances=True):
# check if url rules are for build only
if comp.build_only:
new_map = []
for rule in comp.url_rules:
rule.build_only = True
new_map.append(rule)
comp.url_rules = new_map
name = comp.name
# Give subclasses of UrlMixin a way to further modify the rules.
rules = cls.modify_urlrules(comp)
if name:
subdomain, mount = ctx.cfg['routing.urls.' + name].split(':', 1)
if not comp.ignore_prefix:
prefix = name
rules = [EndpointPrefix('%s/' % prefix, rules)]
val = Submount(mount, rules)
if subdomain != '':
val = Subdomain(subdomain, [val])
urls.append(val)
else:
urls.extend(rules)
cls._endpoint_map.setdefault(name, {}).update(comp.get_endpoint_map())
return urls
def iter_middlewares(cls):
"""Return all middlewares ordered by priority."""
if not cls._middlewares:
cls._middlewares = sorted(
ctx.get_implementations(cls, instances=True),
key=lambda x: (- x.priority))
ret = cls._middlewares
return ret
def get_search_indexes(cls):
"""
Generates a name -> `SearchIndex` mapping of all search indexes.
"""
dct = {}
for component in ctx.get_implementations(cls, instances=True):
for index in component.search_indexes:
dct[index.name] = index
return dct
def get_search_indexes(cls):
"""
Generates a name -> `SearchIndex` mapping of all search indexes.
"""
dct = {}
for component in ctx.get_implementations(cls, instances=True):
for index in component.search_indexes:
dct[index.name] = index
return dct
def __init__(self, string, transformers=None):
"""
In theory you never have to instanciate this parser yourself because
the high level `parse()` function encapsulates this. However for the
unittests it's important to be able to disable and enable the
`transformers` by hand. If you don't provide any transformers the
default transformers are used.
"""
self.string = string
self.lexer = Lexer()
self.stack_depth = 0
if transformers is None:
transformers = ctx.get_implementations(ITransformer,
instances=True)
self.transformers = transformers
#: node dispatchers
self._handlers = {
'text': self.parse_text,
'raw': self.parse_raw,
'nl': self.parse_nl,
'highlighted_begin': self.parse_highlighted,
'conflict_begin': self.parse_conflict_left,
'conflict_switch': self.parse_conflict_middle,
'conflict_end': self.parse_conflict_end,
'metadata_begin': self.parse_metadata,
'headline_begin': self.parse_headline,
'strong_begin': self.parse_strong,
'emphasized_begin': self.parse_emphasized,
'escaped_code_begin': self.parse_escaped_code,
'code_begin': self.parse_code,
'underline_begin': self.parse_underline,
'stroke_begin': self.parse_stroke,
'small_begin': self.parse_small,
'big_begin': self.parse_big,
'sub_begin': self.parse_sub,
'sup_begin': self.parse_sup,
'footnote_begin': self.parse_footnote,
'color_begin': self.parse_color,
'size_begin': self.parse_size,
'font_begin': self.parse_font,
'quote_begin': self.parse_quote,
'list_item_begin': self.parse_list,
'definition_begin': self.parse_definition,
'external_link_begin': self.parse_external_link,
'free_link': self.parse_free_link,
'ruler': self.parse_ruler,
'pre_begin': self.parse_pre_block,
'table_row_begin': self.parse_table,
'box_begin': self.parse_box,
'sourcelink': self.parse_source_link
}
#: runtime information
self.is_dirty = False
def get_search_providers(cls):
"""
Generates a dictionary whose keys are the search index names and whose
values are dictionaries of the search providers belonging to them.
"""
dct = {}
for component in ctx.get_implementations(cls, instances=True):
for provider in component.search_providers:
dct.setdefault(provider.index, {})
dct[provider.index][provider.name] = provider
return dct
def __init__(self, string, transformers=None):
"""
In theory you never have to instanciate this parser yourself because
the high level `parse()` function encapsulates this. However for the
unittests it's important to be able to disable and enable the
`transformers` by hand. If you don't provide any transformers the
default transformers are used.
"""
self.string = string
self.lexer = Lexer()
self.stack_depth = 0
if transformers is None:
transformers = ctx.get_implementations(ITransformer, instances=True)
self.transformers = transformers
#: node dispatchers
self._handlers = {
'text': self.parse_text,
'raw': self.parse_raw,
'nl': self.parse_nl,
'highlighted_begin': self.parse_highlighted,
'conflict_begin': self.parse_conflict_left,
'conflict_switch': self.parse_conflict_middle,
'conflict_end': self.parse_conflict_end,
'metadata_begin': self.parse_metadata,
'headline_begin': self.parse_headline,
'strong_begin': self.parse_strong,
'emphasized_begin': self.parse_emphasized,
'escaped_code_begin': self.parse_escaped_code,
'code_begin': self.parse_code,
'underline_begin': self.parse_underline,
'stroke_begin': self.parse_stroke,
'small_begin': self.parse_small,
'big_begin': self.parse_big,
'sub_begin': self.parse_sub,
'sup_begin': self.parse_sup,
'footnote_begin': self.parse_footnote,
'color_begin': self.parse_color,
'size_begin': self.parse_size,
'font_begin': self.parse_font,
'quote_begin': self.parse_quote,
'list_item_begin': self.parse_list,
'definition_begin': self.parse_definition,
'external_link_begin': self.parse_external_link,
'free_link': self.parse_free_link,
'ruler': self.parse_ruler,
'pre_begin': self.parse_pre_block,
'table_row_begin': self.parse_table,
'box_begin': self.parse_box,
'sourcelink': self.parse_source_link
}
#: runtime information
self.is_dirty = False
def get_search_providers(cls):
"""
Generates a dictionary whose keys are the search index names and whose
values are dictionaries of the search providers belonging to them.
"""
dct = {}
for component in ctx.get_implementations(cls, instances=True):
for provider in component.search_providers:
dct.setdefault(provider.index, {})
dct[provider.index][provider.name] = provider
return dct
def __init__(self):
loaders = {}
for resource in ctx.get_implementations(IResourceManager, instances=True):
loaders[resource.resource_name] = FileSystemLoader(resource.templates_path)
loader = ChoiceLoader([FileSystemLoader(ctx.cfg['templates.path']),
PrefixLoader(loaders)])
cache_obj = None
if ctx.cfg['templates.use_cache']:
if ctx.cfg['templates.use_memcached_cache']:
cache_obj = MemcachedBytecodeCache(
client=inyoka_cache,
timeout=ctx.cfg['caching.timeout']
)
elif ctx.cfg['templates.use_filesystem_cache']:
cache_obj = FileSystemBytecodeCache(
directory=ctx.cfg['caching.filesystem_cache_path'],
)
Environment.__init__(self,
loader=loader,
extensions=['jinja2.ext.i18n', 'jinja2.ext.do', 'jinja2.ext.with_',
'jinja2.ext.autoescape'],
auto_reload=ctx.cfg['templates.auto_reload'],
undefined=StrictUndefined,
cache_size=-1,
bytecode_cache=cache_obj,
autoescape=True
)
self.globals.update(
INYOKA_REVISION=INYOKA_REVISION,
PYTHON_VERSION='%d.%d.%d' % sys.version_info[:3],
DEBUG=ctx.cfg['debug'],
href=href,
)
self.filters.update(
jsonencode=json.dumps,
datetimeformat=l10n.format_datetime,
dateformat=l10n.format_date,
timeformat=l10n.format_time,
timedelta=l10n.timedeltaformat,
monthformat=l10n.format_month,
dayformatshort=l10n.format_day_short,
humanize=l10n.humanize_number,
)
self.install_gettext_translations(
i18n.get_translations(),
newstyle=True
)
def get_models(cls, tables=False):
"""Generator that yields all registered models. Yields tables
if `tables` is set to True.
"""
for component in ctx.get_implementations(cls, instances=True):
for model in component.models:
is_table = isinstance(model, Table)
if is_table and not tables:
continue
if is_table and tables:
yield model
else:
yield model.__table__ if tables else model
def get_models(cls, tables=False):
"""Generator that yields all registered models. Yields tables
if `tables` is set to True.
"""
for component in ctx.get_implementations(cls, instances=True):
for model in component.models:
is_table = isinstance(model, Table)
if is_table and not tables:
continue
if is_table and tables:
yield model
else:
yield model.__table__ if tables else model
def tag(self, request, slug):
tag = Tag.query.filter_by(slug=slug).one()
providers = ctx.get_implementations(ITaggableContentProvider, instances=True)
content = []
for provider in providers:
content.append({
'item_list': provider.get_taggable_content(tag).all(),
'list_class': provider.type,
'name': provider.name
})
return {
'tag': tag,
'content': content,
}
def __init__(self, ctx):
IController.__init__(self, ctx)
self.extensions = dict((ext.ext_key, ext.ext_name)
for ext in ctx.get_implementations(UserCPExtension))
