def apply_tinytextile(content, context):
""" tinyTextile markup """
from PyLucid.system.markups.tinyTextile import TinyTextileParser
out_obj = SimpleStringIO()
markup_parser = TinyTextileParser(out_obj, context)
markup_parser.parse(content)
return out_obj.getvalue()
def render(self, context):
local_response = SimpleStringIO()
output = run(
context, local_response,
self.plugin_name, self.method_name,
method_kwargs = self.method_kwargs
)
if output == None:
content = local_response.getvalue()
elif isinstance(output, basestring):
content = output
else:
msg = (
"Error: Wrong output from inline Plugin!"
" - It should be write into the response object and return None"
" or return a basestring!"
" - But %s.%s has returned: %s (%s)"
) % (
self.plugin_name, self.method_name,
repr(output), type(output)
)
raise AssertionError(msg)
if not self.plugin_name in CSS_TAG_BLACKLIST:
content = add_css_tag(
context, content, self.plugin_name, self.method_name
)
return content
def handle_command(request, page_id, module_name, method_name, url_args):
"""
handle a _command request
"""
current_page_obj = _get_page(request, page_id)
context = _get_context(request, current_page_obj)
local_response = SimpleStringIO()
if url_args == "":
url_args = ()
else:
url_args = (url_args,)
try:
output = plugin_manager.handle_command(
context, local_response, module_name, method_name, url_args
)
except AccessDenied:
if request.debug:
# don't use errorhandling -> raise the prior error
raise
page_content = "[Permission Denied!]"
else:
if output == None:
# Plugin/Module has retuned the locale StringIO response object
page_content = local_response.getvalue()
elif isinstance(output, basestring):
page_content = output
elif isinstance(output, HttpResponse):
# e.g. send a file directly back to the client
return output
else:
msg = (
"Error: Wrong output from Plugin!"
" - It should be write into the response object"
" or return a String/HttpResponse object!"
" - But %s.%s has returned: %s (%s)"
) % (
module_name, method_name,
escape(repr(output)), escape(str(type(output)))
)
raise AssertionError(msg)
# print module_name, method_name
# print page_content
# print "---"
if page_content:
# Add the CSS Info, but only if the plugin has returned content and
# not when the normal cms page rendered.
page_content = add_css_tag(
context, page_content, module_name, method_name
)
return _render_cms_page(request, context, page_content)
def _redirect_execute(self, method, *args, **kwargs):
"""
run a method an redirect stdout writes (print) into a Buffer.
puts the redirected outputs into self.context["output"].
usefull to run django management functions.
"""
redirect = SimpleStringIO()
old_stdout = sys.stdout
sys.stdout = redirect
old_stderr = sys.stderr
sys.stderr = redirect
try:
try:
method(*args, **kwargs)
finally:
sys.stdout = old_stdout
sys.stderr = old_stderr
output = redirect.getvalue()
except Exception, e:
# Display the written output
# FixMe: There should be exist a better way for this.
print output
raise
def setUp(self):
self.fake_context = get_fake_context()
self.out = SimpleStringIO()
self.textile = TinyTextileParser(self.out, self.fake_context)
class tinyTextileTest(unittest_addons.MarkupTest):
def setUp(self):
self.fake_context = get_fake_context()
self.out = SimpleStringIO()
self.textile = TinyTextileParser(self.out, self.fake_context)
def tearDown(self):
""" delete the out buffer """
self.out.data = []
#_________________________________________________________________________
def _parse(self, txt):
"""
Apply tinyTextile markup on txt
"""
self.out._container = [] # delete the out buffer
self.textile.parse(txt)
out_string = self.out.getvalue()
return out_string
def _processTinyTextile(self, source_string, should_string):
"""
prepate the given text and apply the markup.
"""
source = self._prepare_text(source_string)
should = self._prepare_text(should_string)
out_string = self._parse(source)
return out_string, should
def assertTinyTextile(self, source_string, should_string):
"""
applies the tinyTextile markup to the given source_string and compairs
it with the should_string.
"""
out_string, should = self._processTinyTextile(
source_string, should_string
)
self.assertEqual(out_string, should)
def assertTinyTextileList(self, source_string, should_string):
"""
tinyTextile doesn't indented lists well. Here we use a work-a-round.
"""
out_string, should = self._processTinyTextile(
source_string, should_string
)
def format_output(txt):
return "\n".join([i.strip() for i in txt.splitlines()])
out_string = format_output(out_string)
should = format_output(should)
self.assertEqual(out_string, should)
#_________________________________________________________________________
def testTextile_text1(self):
out_string = self._parse("text")
self.assertEqual(out_string, "<p>text</p>\n")
def testTextile_text2(self):
self.assertTinyTextile(r"""
Force\\linebreak
""", """
<p>Force<br />linebreak</p>\n
""")
def testTextile_text3(self):
self.assertTinyTextile("""
text block 1
text block 1 line 2
text block 2
text block 2 line 2
\r
windows 1\r
windows 2\r
\r
mac 1\r
mac 2\r
""", """
<p>text block 1<br />
text block 1 line 2</p>
<p>text block 2<br />
text block 2 line 2</p>
<p>windows 1<br />
windows 2</p>
<p>mac 1<br />
mac 2</p>
""")
def testTextile_backslash(self):
self.assertTinyTextile(r"""
a windows path:
C:\windows\foo\bar\
a linux path:
/usr/bin/python
a manuel linebreak\\with two backslashes
""", r"""
<p>a windows path:<br />
C:\windows\foo\bar\<br />
a linux path:<br />
/usr/bin/python<br />
a manuel linebreak<br />with two backslashes</p>
""")
def testTextile_headline1(self):
self.assertTinyTextile("""
h1. headline A
Text1
h2. headline B $%#
Text2
""", """
<h1>headline A</h1>
<p>Text1</p>
<h2>headline B $%#</h2>
<p>Text2</p>
""")
def testTextile_pre(self):
self.assertTinyTextile("""
text above pre area
<pre>
test in pre 1
test in pre 2
test in pre 3
test in pre 4
no\\line\\break
</pre>
text line under pre area
some text...
a inline <pre>pre area</pre> in a text line
...some other text
""", """
<p>text above pre area</p>
<pre>
test in pre 1
test in pre 2
test in pre 3
test in pre 4
no\\line\\break
</pre>
<p>text line under pre area</p>
<p>some text...<br />
a inline <pre>pre area</pre> in a text line<br />
...some other text</p>
""")
def testTextile_code1(self):
self.assertTinyTextile("""
<code=py>
testcode
</code>
""", """
<fieldset class="pygments_code">
<legend class="pygments_code">py</legend>
<pre><code>testcode</code></pre>
</fieldset>
""")
def testTextile_code2(self):
self.assertTinyTextile("""
text above code area 1
<code=ext>
test in code 1
test in code 2
</code>
text line under code area 1
text above code area 2
<code>
test in code 1
test in code 2
</code>
text line under code area 2
some text...
a inline <code>code area</code> in a text line
...some other text
""", """
<p>text above code area 1</p>
<fieldset class="pygments_code">
<legend class="pygments_code">ext</legend>
<pre><code>test in code 1
test in code 2</code></pre>
</fieldset>
<p>text line under code area 1</p>
<p>text above code area 2</p>
<fieldset class="pygments_code">
<legend class="pygments_code"></legend>
<pre><code>test in code 1
test in code 2</code></pre>
</fieldset>
<p>text line under code area 2</p>
<p>some text...<br />
a inline <code>code area</code> in a text line<br />
...some other text</p>
""")
def testTextile_SourceCode1(self):
"""
A known bug: sourcecode parts doesn't handled well. See doc string in
tinyTextile.py!
Here we do a "work-a-round" and delete all linebreaks (\n).
"""
source_string = """
<python>
class Example():
def __init__(self, *args, **kwargs):
# Text1
# Text2
a = b + c + 1
# text 3
# text 4
# text 5 no\\line\\break
# text 6
</python>
"""
should_string = """
<fieldset class="pygments_code">
<legend class="pygments_code">python</legend>
<pre><code>class Example():
def __init__(self, *args, **kwargs):
# Text1
# Text2
a = b + c + 1
# text 3
# text 4
# text 5 no\\line\\break
# text 6</code></pre>
</fieldset>
"""
out_string, should = self._processTinyTextile(
source_string, should_string
)
def format_output(txt):
return txt.replace("\n", "")
out_string = format_output(out_string)
should = format_output(should)
self.assertEqual(out_string, should)
def testTextile_SourceCode2(self):
"""
A known bug: sourcecode parts doesn't handled well. See doc string in
tinyTextile.py!
"""
print (
"skip testTextile_SourceCode2()"
" - tinyTextile known sourcecode part bug"
)
return
self.assertTinyTextile("""
<python>
class Example():
def __init__(self, *args, **kwargs):
# Text1
# Text2
a = b + c + 1
# text 3
# text 4
# text 5
# text 6
</python>
""", """
<fieldset class="pygments_code">
<legend class="pygments_code">python</legend>
<pre><code>class Example():
def __init__(self, *args, **kwargs):
# Text1
# Text2
a = b + c + 1
# text 3
# text 4
# text 5
# text 6</code></pre>
</fieldset>
""")
self.textile.parse(content)
self.assertEqual(self.out.getvalue(), out_test)
def testTextile_escaping1(self):
self.assertTinyTextile("""
escape ==<ul>== and ==<ol>== with "==" ;)
""", """
<p>escape <ul> and <ol> with "==" ;)</p>\n
""")
def testTextile_escaping2(self):
self.assertTinyTextile("""
text above
==
<a href="#">bla</a>
<strong>Hier alles Escapen!</strong>
==
text line under
inline ==<escape>== Blabla
<python>
print "=="
print "Huch"
print "=="
</python>
some text...
==
<code>
Zeile 1
Zeile 3
Zeile 5
</code>
==
""", """
<p>text above<br />
<br />
<a href="#">bla</a><br />
<strong>Hier alles Escapen!</strong><br />
<br />
text line under</p>
<p>inline <escape> Blabla</p>
<fieldset class="pygments_code">
<legend class="pygments_code">python</legend>
<pre><code>print "=="
print "Huch"
print "=="</code></pre>
</fieldset>
<p>some text...</p>
<br />
<code><br />
Zeile 1<br />
<br />
Zeile 3<br />
<br />
Zeile 5<br />
</code><br />
""")
def testTextile_list1(self):
self.assertTinyTextileList("""
text above
* list1
** blub
* bla
**** foo
**** bar
text line under
""", """
<p>text above</p>
<ul>
<li>list1</li>
<ul>
<li>blub</li>
</ul>
<li>bla</li>
<ul>
<ul>
<ul>
<li>foo</li>
<li>bar</li>
</ul>
</ul>
</ul>
</ul>
<p>text line under</p>
""")
def testTextile_list2(self):
self.assertTinyTextileList("""
text above
# list1
## blub
# bla
#### foo
#### bar
text line under
""", """
<p>text above</p>
<ol>
<li>list1</li>
<ol>
<li>blub</li>
</ol>
<li>bla</li>
<ol>
<ol>
<ol>
<li>foo</li>
<li>bar</li>
</ol>
</ol>
</ol>
</ol>
<p>text line under</p>
""")
def testTextile_links_urls(self):
self.assertTinyTextile("""
http://domain.dtl
ftp://domain.dtl
mailto:[email protected]
""", """
<p><a href="http://domain.dtl">http://domain.dtl</a><br />
<a href="ftp://domain.dtl">ftp://domain.dtl</a><br />
<a href="mailto:[email protected]">[email protected]</a></p>
""")
def testTextile_links_old(self):
"""
The old tinyTextile link format.
"""
self.assertTinyTextile("""
a "link text":http://domain.dtl
This is a link, too: "Link":#unten
Shortcut link: [[PageName]] !
""", """
<p>a <a href="http://domain.dtl">link text</a><br />
This is a link, too: <a href="#unten">Link</a><br />
Shortcut link: <a href="/PageName/">PageName</a> !</p>
""")
def testTextile_links_new(self):
"""
The new tinyTextile link format.
"""
self.assertTinyTextile("""
a [http://domain.dtl link text]
This is a link, too: [#unten Link]
Shortcut link: [[PageName]] !
""", """
<p>a <a href="http://domain.dtl">link text</a><br />
This is a link, too: <a href="#unten">Link</a><br />
Shortcut link: <a href="/PageName/">PageName</a> !</p>
""")
def testTextile_table1(self):
self.assertTinyTextile(r"""
table 1 start
|=Heading Col 1 |=Heading Col 2 |
|Cell 1.1 |2 lines\\in Cell 1.2 |
|Cell 2.1 |Cell 2.2 |
table 1 end
|Cell 1.1 |Cell 1.2 |Cell 1.3 |
|Cell 2.1 |Cell 2.2 |Cell 2.3 |
""", """
<p>table 1 start</p>
<table>
<tr>
\t<th>Heading Col 1</th>
\t<th>Heading Col 2</th>
</tr>
<tr>
\t<td>Cell 1.1</td>
\t<td>2 lines<br />in Cell 1.2</td>
</tr>
<tr>
\t<td>Cell 2.1</td>
\t<td>Cell 2.2</td>
</tr>
</table>
<p>table 1 end</p>
<table>
<tr>
\t<td>Cell 1.1</td>
\t<td>Cell 1.2</td>
\t<td>Cell 1.3</td>
</tr>
<tr>
\t<td>Cell 2.1</td>
\t<td>Cell 2.2</td>
\t<td>Cell 2.3</td>
</tr>
</table>
""")
try:
if ext == "":
lexer = lexers.guess_lexer(sourcecode)
else:
lexer = lexers.get_lexer_by_name(ext)
except lexers.ClassNotFound, err:
info = _("unknown type")
lexer_name = u'<small title="%s">%s</small>' % (err, info)
html = no_hightlight(sourcecode)
return html, lexer_name
lexer_name = lexer.name
formatter = get_formatter()
out_object = SimpleStringIO()
try:
highlight(sourcecode, lexer, formatter, out_object)
except Exception, err:
if settings.DEBUG:
raise
html = no_hightlight(sourcecode)
lexer_name += " (Error: %s)" % err
else:
html = out_object.getvalue()
# If there is e.g. html code with django tags, we must escape this:
html = escape_django_tags(html)
html = html.decode("utf-8")
return html, lexer_name
