def parse_creole(request, markup):
"""Parse some creole markup and create a genshi stream."""
return Parser(dialect=Creole10(
wiki_links_base_url=request.url_root,
wiki_links_space_char='_',
no_wiki_monospace=True,
use_additions=True
)).generate(markup)
app = get_application()
for extension in app.markup_extensions:
macros[extension.name] = make_macro(extension)
macros_set_up = True
if macro_name in macros:
return macros[macro_name](body, args, kwargs, is_block, environ)
zinecreole = create_dialect(creole11_base,
wiki_links_base_url=u'',
wiki_links_path_func=path_func,
wiki_links_space_char=u'_',
no_wiki_monospace=True,
macro_func=macro_func)
creole_parser = Parser(dialect=zinecreole())
class CreoleParser(BaseParser):
"""Creole wiki markup parser.
>>> p = CreoleParser(app=None)
>>> p.parse(u'Hello **there**', 'entry').to_html()
u'<p>Hello <strong>there</strong></p>\\n'
>>> p.parse(u'<<intro>>\\nHello //again//\\n<</intro>>\\n '
... u'that was the __intro__.', 'entry').to_html()
u'<intro><p>Hello <em>again</em></p>\\n</intro><p> that was the <u>intro</u>.</p>\\n'
"""
name = _(u'Creole')
#!/usr/bin/env python
import os
import sqlite3
import macros
from creoleparser import Parser, create_dialect, creole11_base
import circuits
from circuits.web import Controller, Logger, Server, Static
text2html = Parser(create_dialect(creole11_base, macro_func=macros.dispatcher),
method="xhtml")
class Wiki(object):
def __init__(self, database):
super(Wiki, self).__init__()
create = not os.path.exists(database)
self._cx = sqlite3.connect(database)
self._cu = self._cx.cursor()
if create:
self._cu.execute("CREATE TABLE pages (name, text)")
for defaultpage in os.listdir("defaultpages"):
filename = os.path.join("defaultpages", defaultpage)
self.save(defaultpage, open(filename, "r").read())
def save(self, name, text):
self._cu.execute("SELECT COUNT() FROM pages WHERE name=?", (name, ))
def wiki_link_cb(page_name):
if page_name.startswith('media:'):
return settings.MEDIA_URL + page_name.replace('media:', '', count=1)
else:
if page_name_re.match(page_name):
return reverse('scenario.show', args=(page_name, ))
else:
return False
def wiki_image_cb(page_name):
return settings.MEDIA_URL + page_name
_non_bodied_macros = {'ip': ip}
_bodied_macros = {
'enterSecret': enter_secret,
'requireSecret': require_secret,
'spoiler': spoiler,
'code': code,
'color': color,
'highlight': highlight_
}
_dialect = create_dialect(creole11_base,
non_bodied_macros=_non_bodied_macros,
bodied_macros=_bodied_macros,
custom_markup=[(comment_re, comment)],
wiki_links_path_func=[wiki_link_cb, wiki_image_cb])
render_scenario = Parser(dialect=_dialect, method='xhtml')
def __init__(self, config):
super(Environment, self).__init__()
self.config = config
self.dbm = DatabaseManager(
self.config.get("db"),
echo=(self.config.get("debug") and self.config.get("verbose")),
).register(self)
self.storage = DefaultStorage(
self.config,
self.config.get("repo"),
charset=self.config.get("encoding"),
)
self.search = WikiSearch(
self.dbm.session,
self.config.get("language"),
self.storage,
)
self.parser = Parser(create_dialect(
creole11_base,
macro_func=macros.dispatcher,
wiki_links_base_url="/",
wiki_links_class_func=self._wiki_links_class_func,
wiki_links_path_func=self._wiki_links_path_func,
),
method="xhtml")
template_config = {
"allow_exec":
False,
"auto_reload":
True,
"default_encoding":
self.config.get("encoding"),
"search_path": [
self.storage.path,
os.path.join(self.config.get("theme"), "templates"),
],
"variable_lookup":
"lenient",
}
self.templates = TemplateLoader(**template_config)
self.macros = macros.loadMacros()
self.stylesheets = []
self.version = sahriswiki.__version__
self.site = {
"name": self.config.get("name"),
"author": self.config.get("author"),
"keywords": self.config.get("keywords"),
"description": self.config.get("description"),
}
self.request = None
self.response = None
def restore(self, creole):
self.hyperMgr.reset()
document = Parser(unicode(creole, 'utf-8', 'ignore')).parse()
return TextTagEmitter(document, self.txt, self.hyperMgr,
self.bullet_image).emit()
template_loader = TemplateLoader(TEMPLATE_PATH,
auto_reload=True,
variable_lookup='lenient')
# context locals. these two objects are use by the application to
# bind objects to the current context. A context is defined as the
# current thread and the current greenlet if there is greenlet support.
local = Local()
local_manager = LocalManager([local])
request = local('request')
application = local('application')
# create a new creole parser
creole_parser = Parser(
dialect=Creole10(wiki_links_base_url='',
wiki_links_path_func=lambda page_name: href(page_name),
wiki_links_space_char='_',
no_wiki_monospace=True,
use_additions=True))
def generate_template(template_name, **context):
"""Load and generate a template."""
context.update(href=href, format_datetime=format_datetime)
return template_loader.load(template_name).generate(**context)
def parse_creole(markup):
"""Parse some creole markup and create a genshi stream."""
return creole_parser.generate(markup)
from creoleparser import Parser, create_dialect, creole11_base
def enter_secret(macro, environ, *secrets):
environ['secrets'].update(secrets)
def macro_func(name, argument, body, type, environ):
return body
_dialect = create_dialect(creole11_base, macro_func=macro_func,
bodied_macros={'enterSecret': enter_secret},)
_render = Parser(dialect=_dialect, method='xhtml')
def extract_secrets(text):
environ = {'secrets': set()}
# Parse to populate environ['secrets'], discard xhtml
_render(text, environ=environ)
return environ['secrets']