def markup(value, arg=''):
if arg == 'rst':
from docutils.core import publish_parts
docutils_settings = getattr(settings, "RESTRUCTUREDTEXT_FILTER_SETTINGS", {})
parts = publish_parts(source=smart_str(value), writer_name="html4css1", settings_overrides=docutils_settings)
return mark_safe(force_unicode(parts["html_body"]))
elif arg == 'markdown':
import markdown
extensions = ['codehilite']
safe_mode = True
return mark_safe(markdown.markdown(force_unicode(value), extensions, safe_mode=safe_mode))
elif arg == 'textile':
import textile
return mark_safe(force_unicode(textile.textile(smart_str(value), encoding='utf-8', output='utf-8')))
elif arg == 'creole':
import creoleparser
from creole_macros import pygments_macro
dialect = creoleparser.create_dialect(creoleparser.dialects.creole11_base, macro_func=pygments_macro)
parser = creoleparser.Parser(dialect=dialect)
return mark_safe(parser(value))
elif arg == 'html':
return mark_safe(value)
elif arg == 'txt':
return mark_safe('<pre>%s</pre>' % value)
else:
return value
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
"""Macro for spoiler. Showing and hiding it is done via javascript."""
return tag.div(macro.parsed_body(), class_='spoiler')
def ip(macro, environ):
"""Macro for the virtual machine's ip."""
ip = environ.get('ip')
if not ip:
ip = '127.0.0.1'
return tag.span(ip, class_='ip')
def code(macro, environ, lang='text', linenos=False):
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))
_non_bodied_macros = {'ip': ip}
_bodied_macros = {
'enterSecret': enter_secret,
'requireSecret': require_secret,
'spoiler': spoiler,
'code': code
}
_dialect = create_dialect(creole11_base, non_bodied_macros=_non_bodied_macros,
bodied_macros=_bodied_macros)
render_scenario = Parser(dialect=_dialect, method='xhtml')
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 = creoleparser.Parser(
dialect=creoleparser.create_dialect(
creoleparser.creole10_base,
wiki_links_base_url="",
wiki_links_path_func=lambda page_name: href(page_name),
wiki_links_space_char="_",
no_wiki_monospace=True,
),
method="html",
)
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."""
def wiki_links_path_func(src):
if (".com" in src or
".net" in src or
".org" in src):
return "http://%s" % src
return to_slug(src)
def wiki_links_class_func(src):
if (".com" in src or
".net" in src or
".org" in src):
return "external"
if not redis.exists("n:" + to_slug(src)):
return "missing"
dialect = creoleparser.create_dialect(
creoleparser.creole11_base,
wiki_links_class_func=wiki_links_class_func,
wiki_links_path_func=wiki_links_path_func,
wiki_links_space_char="-",
bodied_macros={'menu': menu, 'hidden': hidden, 'float': float, 'imagebox': imagebox, 'center': center},
non_bodied_macros={'related': related, 'recent': recent})
parser = creoleparser.Parser(dialect, encoding=None)
def text2html(src):
from wiki import re_related
src = re_related.sub(r"[[\2]]", src)
return parser( src )
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')
args, kwargs = parse_args(arg_string)
if macro_name == "intro" and body:
return intro_tag(body)
if not macros_set_up:
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)
rezinecreole = 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=rezinecreole())
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()
global macros_set_up
args, kwargs = parse_args(arg_string)
if macro_name == 'intro' and body:
return intro_tag(body)
if not macros_set_up:
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'
# 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 = creoleparser.Parser(
dialect=creoleparser.create_dialect(
creoleparser.creole10_base,
wiki_links_base_url="",
wiki_links_path_func=lambda page_name: href(page_name),
wiki_links_space_char="_",
no_wiki_monospace=True,
),
method="html",
)
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."""
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
anchor, escape(title))
return res + u'</ul>'
def parse_page(body_raw, environ, area):
# Factory link creation function to use current area.
wiki_parser.dialect.link.path_func = get_wiki_link_func(area)
# Parse wiki markup.
body = wiki_parser(body_raw, environ=environ)
toc = get_toc(environ.get('toc'))
return (body, toc)
heading_re = re.compile(heading_re_string(), re.MULTILINE)
dialect = creoleparser.create_dialect(
creoleparser.dialects.creole11_base,
macro_func=parse_macro,
)
dialect.headings = Heading(['h1','h2','h3','h4','h5','h6'], '=')
wiki_parser = creoleparser.Parser(dialect=dialect, encoding=None)
MACROS = {
'code': macro_code,
'note': macro_note,
'warning': macro_note,
'seealso': macro_note,
}
#!/usr/bin/env python
import os
import sqlite3
from creoleparser import create_dialect, creole11_base, Parser
import circuits
from circuits.web import Server, Controller, Logger, Static
import macros
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"):
"""Macro for the virtual machine's ip."""
ip = environ.get('ip')
if not ip:
ip = '127.0.0.1'
return tag.span(ip, class_='ip')
def code(macro, environ, lang='text', linenos=False):
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))
comment_re = re.compile('\{#(.+?)#\}')
def comment(match, environ):
return Markup()
_non_bodied_macros = {'ip': ip}
_bodied_macros = {
'enterSecret': enter_secret,
'requireSecret': require_secret,
'spoiler': spoiler,
'code': code
}
_dialect = create_dialect(creole11_base, non_bodied_macros=_non_bodied_macros,
bodied_macros=_bodied_macros, custom_markup=[(comment_re, comment)])
render_scenario = Parser(dialect=_dialect, method='xhtml')
return res + u'</ul>'
def parse_page(body_raw, environ, area):
# Factory link creation function to use current area.
wiki_parser.dialect.link.path_func = get_wiki_link_func(area)
# Parse wiki markup.
body = wiki_parser(body_raw, environ=environ)
toc = get_toc(environ.get('toc'))
return (body, toc)
heading_re = re.compile(heading_re_string(), re.MULTILINE)
dialect = creoleparser.create_dialect(
creoleparser.dialects.creole11_base,
#wiki_links_path_func=create_wiki_link,
macro_func=parse_macro,
)
dialect.headings = Heading(['h1','h2','h3','h4','h5','h6'], '=')
wiki_parser = creoleparser.Parser(dialect=dialect, encoding=None)
MACROS = {
'code': macro_code,
'note': macro_note,
'warning': macro_note,
'seealso': macro_note,
}
super(CodeBlock, self).__init__('pre', ['{{{', '}}}'])
def _build(self, mo, element_store, environ):
lines = self.regexp2.sub(r'\1', mo.group(1)).splitlines()
if lines and lines[0].startswith('#!'):
try:
lexer = get_lexer_by_name(lines.pop(0)[2:].strip())
except ClassNotFound:
pass
else:
return Markup(
highlight(u'\n'.join(lines), lexer, pygments_formatter))
return builder.tag.pre(u'\n'.join(lines))
custom_dialect = creoleparser.create_dialect(creoleparser.creole10_base)
# hacky way to get rid of image support
custom_dialect.img = custom_dialect.no_wiki
custom_dialect.pre = CodeBlock()
_parser = creoleparser.Parser(dialect=custom_dialect, method='html')
def format_creole(text):
return Markup(_parser.render(text, encoding=None))
def split_lines_wrapping(text, width=74, threshold=82):
lines = text.splitlines()
if all(len(line) <= threshold for line in lines):
return lines
#!/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, ))
"""
from __future__ import with_statement
import re
import creoleparser
from difflib import SequenceMatcher
from operator import itemgetter
from itertools import chain
from genshi.core import Stream, QName, Attrs, START, END, TEXT
from contextlib import contextmanager
from jinja2 import Markup
_leading_space_re = re.compile(r'^(\s+)(?u)')
_diff_split_re = re.compile(r'(\s+)(?u)')
_parser = creoleparser.Parser(dialect=creoleparser.create_dialect(
creoleparser.creole10_base),
method='html')
def format_creole(text, inline=False):
"""Format creole markup."""
kwargs = {}
if inline:
kwargs['context'] = 'inline'
return Markup(_parser.render(text, encoding=None, **kwargs))
def format_creole_diff(old, new):
"""Renders a creole diff for two texts."""
differ = StreamDiffer(_parser.generate(old), _parser.generate(new))
return Markup(differ.get_diff_stream().render('html', encoding=None))
super(CodeBlock, self).__init__('pre', ['{{{', '}}}'])
def _build(self, mo, element_store, environ):
lines = self.regexp2.sub(r'\1', mo.group(1)).splitlines()
if lines and lines[0].startswith('#!'):
try:
lexer = get_lexer_by_name(lines.pop(0)[2:].strip())
except ClassNotFound:
pass
else:
return Markup(highlight(u'\n'.join(lines), lexer,
pygments_formatter))
return builder.tag.pre(u'\n'.join(lines))
custom_dialect = creoleparser.create_dialect(creoleparser.creole10_base)
# hacky way to get rid of image support
custom_dialect.img = custom_dialect.no_wiki
custom_dialect.pre = CodeBlock()
_parser = creoleparser.Parser(
dialect=custom_dialect,
method='html'
)
def format_creole(text):
return Markup(_parser.render(text, encoding=None))
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 = creoleparser.Parser(dialect=creoleparser.create_dialect(
creoleparser.creole10_base,
wiki_links_base_url='',
wiki_links_path_func=lambda page_name: href(page_name),
wiki_links_space_char='_',
no_wiki_monospace=True),
method='html')
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)
page_name_re = re.compile('^[\w-]+$')
def comment(match, environ):
return Markup()
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')
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']
