This is a test.
Link to Slashdot
>>> h3. Notes: * Active development supports Python 2.6 or later (including Python 3.2+). python-textile-2.3.5/TODO.textile 0000664 0000000 0000000 00000000557 13004416251 0016666 0 ustar 00root root 0000000 0000000 TODO * Improve documentation, both of the code and Textile syntax. ** Not all functions have docstrings or adequate docstrings. ** Because the Textile syntax implemented by PyTextile has deviated from the syntax implemented by other implementations of Textile, PyTextile-specific documentation needs to be produced for end-users. * Update to comply with Textile 2.5 python-textile-2.3.5/pytest.ini 0000664 0000000 0000000 00000000153 13004416251 0016542 0 ustar 00root root 0000000 0000000 [pytest] testpaths = tests addopts = --cov=textile --cov-report=html --cov-append --cov-report=term-missing python-textile-2.3.5/requirements.txt 0000664 0000000 0000000 00000000035 13004416251 0017774 0 ustar 00root root 0000000 0000000 html5lib==0.999 Pillow==3.0.0 python-textile-2.3.5/setup.cfg 0000664 0000000 0000000 00000000060 13004416251 0016327 0 ustar 00root root 0000000 0000000 [aliases] test=pytest [bdist_wheel] universal=1 python-textile-2.3.5/setup.py 0000664 0000000 0000000 00000003511 13004416251 0016224 0 ustar 00root root 0000000 0000000 from setuptools import setup, find_packages import os import sys import pytest def get_version(): basedir = os.path.dirname(__file__) with open(os.path.join(basedir, 'textile/version.py')) as f: variables = {} exec(f.read(), variables) return variables.get('VERSION') raise RuntimeError('No version info found.') setup( name='textile', version=get_version(), author='Dennis Burke', author_email='ikirudennis@gmail.com', description='Textile processing for python.', url='http://github.com/textile/python-textile', packages=find_packages(), classifiers=[ 'Development Status :: 5 - Production/Stable', 'Environment :: Web Environment', 'Intended Audience :: Developers', 'License :: OSI Approved :: BSD License', 'Operating System :: OS Independent', 'Programming Language :: Python', 'Topic :: Software Development :: Libraries :: Python Modules', 'Programming Language :: Python', 'Programming Language :: Python :: 2', 'Programming Language :: Python :: 2.6', 'Programming Language :: Python :: 2.7', 'Programming Language :: Python :: 3', 'Programming Language :: Python :: 3.2', 'Programming Language :: Python :: 3.3', 'Programming Language :: Python :: 3.4', 'Programming Language :: Python :: 3.5', ], keywords='textile,text,html markup', install_requires=['six',], extras_require={ ':python_version=="2.6"': ['ordereddict>=1.1'], 'develop': ['regex', 'pytest', 'pytest-cov'], }, entry_points={'console_scripts': ['pytextile=textile.__main__:main']}, setup_requires=['pytest-runner'], tests_require=['pytest', 'pytest-cov'], cmdclass = {'test': pytest}, include_package_data=True, zip_safe=False, ) python-textile-2.3.5/tests/ 0000775 0000000 0000000 00000000000 13004416251 0015654 5 ustar 00root root 0000000 0000000 python-textile-2.3.5/tests/fixtures/ 0000775 0000000 0000000 00000000000 13004416251 0017525 5 ustar 00root root 0000000 0000000 python-textile-2.3.5/tests/fixtures/README.txt 0000664 0000000 0000000 00000003212 13004416251 0021221 0 ustar 00root root 0000000 0000000
python-textile is a Python port of Textile, Dean Allen’s humane web text generator.
pip install textile
Optional dependencies include:
import textile
>>> s = """
... _This_ is a *test.*
...
... * One
... * Two
... * Three
...
... Link to "Slashdot":http://slashdot.org/
... """
>>> html = textile.textile(s)
>>> print html
<p><em>This</em> is a <strong>test.</strong></p>
<ul>
<li>One</li>
<li>Two</li>
<li>Three</li>
</ul>
<p>Link to <a href="http://slashdot.org/">Slashdot</a></p>
>>>text\nmoretext\n\nevenmoretext\n\nmoremoretexttest
' t = textile.Textile() result = t.parse(input) assert result == expect def test_blockcode_in_README(): with open('README.textile') as f: readme = ''.join(f.readlines()) result = textile.textile(readme) with open('tests/fixtures/README.txt') as f: expect = ''.join(f.readlines()) assert result == expect python-textile-2.3.5/tests/test_cli.py 0000664 0000000 0000000 00000001022 13004416251 0020027 0 ustar 00root root 0000000 0000000 import six import subprocess def test_console_script(): command = ['python', '-m', 'textile', 'README.textile'] try: result = subprocess.check_output(command) except AttributeError: command[2] = 'textile.__main__' result = subprocess.Popen(command, stdout=subprocess.PIPE).communicate()[0] with open('tests/fixtures/README.txt') as f: expect = ''.join(f.readlines()) if type(result) == bytes: result = result.decode('utf-8') assert result == expect python-textile-2.3.5/tests/test_footnoteRef.py 0000664 0000000 0000000 00000000374 13004416251 0021563 0 ustar 00root root 0000000 0000000 from textile import Textile import re def test_footnoteRef(): t = Textile() result = t.footnoteRef('foo[1]') expect = 'foo1'.format(t.linkPrefix) assert expect == result python-textile-2.3.5/tests/test_getRefs.py 0000664 0000000 0000000 00000000440 13004416251 0020662 0 ustar 00root root 0000000 0000000 from textile import Textile def test_getRefs(): t = Textile() result = t.getRefs("some text [Google]http://www.google.com") expect = 'some text ' assert result == expect result = t.urlrefs expect = {'Google': 'http://www.google.com'} assert result == expect python-textile-2.3.5/tests/test_getimagesize.py 0000664 0000000 0000000 00000000513 13004416251 0021741 0 ustar 00root root 0000000 0000000 from textile.tools.imagesize import getimagesize import pytest PIL = pytest.importorskip('PIL') def test_imagesize(): assert getimagesize("http://www.google.com/intl/en_ALL/images/logo.gif") == (276, 110) assert getimagesize("http://bad.domain/") == '' assert getimagesize("http://www.google.com/robots.txt") is None python-textile-2.3.5/tests/test_github_issues.py 0000664 0000000 0000000 00000011150 13004416251 0022140 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*- from __future__ import unicode_literals import textile def test_github_issue_16(): result = textile.textile('"$":http://google.com "$":https://google.com "$":mailto:blackhole@sun.comet') expect = '\tgoogle.com google.com blackhole@sun.comet
' assert result == expect def test_github_issue_17(): result = textile.textile('!http://www.ox.ac.uk/favicon.ico!') expect = '\tThis is a link to a Wikipedia article about Textile.
' assert result == expect def test_github_issue_21(): text = '''h1. xml example bc.\n<foo>\n bar\n</foo>\nTy Segall’s
' assert result == expect def test_github_issue_26(): text = '' result = textile.textile(text) expect = '' assert result == expect def test_github_issue_27(): test = """* Folders with ":" in their names are displayed with a forward slash "/" instead. (Filed as "#4581709":/test/link, which was considered "normal behaviour" - quote: "Please note that Finder presents the 'Carbon filesystem' view, regardless of the underlying filesystem.")""" result = textile.textile(test) expect = """\t
def parseWapProfile(self, url):
result = fetch.fetchURL(url)
soup = BeautifulStoneSoup(result['data'], convertEntities=BeautifulStoneSoup.HTML_ENTITIES)
try:
width, height = soup('prf:screensize')[0].contents[0].split('x')
except:
width = height = None
return {"width": width, "height": height}
Of course there's a lot more error handling to do (and useful data to glean off the "XML":XML), but being able to cut through all the usual parsing crap is immensely gratifying."""
result = textile.textile(test)
expect = ("""\tSo here I am porting my ancient newspipe front-end to Snakelets and Python, and I’ve just trimmed down over 20 lines of PHP down to essentially one line of BeautifulSoup retrieval:
def parseWapProfile(self, url):
result = fetch.fetchURL(url)
soup = BeautifulStoneSoup(result['data'], convertEntities=BeautifulStoneSoup.HTML_ENTITIES)
try:
width, height = soup('prf:screensize')[0].contents[0].split('x')
except:
width = height = None
return {"width": width, "height": height}
\tOf course there’s a lot more error handling to do (and useful data to glean off the XML), but being able to cut through all the usual parsing crap is immensely gratifying.
""") assert result == expect def test_github_issue_30(): text ='"Tëxtíle (Tëxtíle)":http://lala.com' result = textile.textile(text) expect = '\t' assert result == expect def test_github_issue_36(): text = '"Chögyam Trungpa":https://www.google.com/search?q=Chögyam+Trungpa' result = textile.textile(text) expect = '\t' assert result == expect python-textile-2.3.5/tests/test_glyphs.py 0000664 0000000 0000000 00000001416 13004416251 0020575 0 ustar 00root root 0000000 0000000 from textile import Textile def test_glyphs(): t = Textile() result = t.glyphs("apostrophe's") expect = 'apostrophe’s' assert result == expect result = t.glyphs("back in '88") expect = 'back in ’88' assert result == expect result = t.glyphs('foo ...') expect = 'foo …' assert result == expect result = t.glyphs('--') expect = '—' assert result == expect result = t.glyphs('FooBar[tm]') expect = 'FooBar™' assert result == expect result = t.glyphs("Cat's Cradle by Vonnegut
") expect = 'Cat’s Cradle by Vonnegut
' assert result == expect result = t.glyphs('test"') expect = 'test” ' assert result == expect python-textile-2.3.5/tests/test_image.py 0000664 0000000 0000000 00000001407 13004416251 0020351 0 ustar 00root root 0000000 0000000 from textile import Textile def test_image(): t = Textile() result = t.image('!/imgs/myphoto.jpg!:http://jsamsa.com') expect = ('Test „quotes”.
' result = TextilePL().parse(test) assert expect == result # Base Textile is unchanged. expect = '\tTest “quotes”.
' result = textile.textile(test) assert expect == result python-textile-2.3.5/tests/test_table.py 0000664 0000000 0000000 00000001447 13004416251 0020362 0 ustar 00root root 0000000 0000000 from textile import Textile def test_table(): t = Textile() result = t.table('(rowclass). |one|two|three|\n|a|b|c|') expect = '\t| one | \n\t\t\ttwo | \n\t\t\tthree | \n\t\t
| a | \n\t\t\tb | \n\t\t\tc | \n\t\t
| one | \n\t\t\ttwo | \n\t\t\tthree | \n\t\t
| a | \n\t\t\tb | \n\t\t\tc | \n\t\t
| * test\n* test | \n\t\t\t1 | \n\t\t\t2 | \n\t\t
YACC1
', html) is not None def test_Footnote(): html = textile.textile('This is covered elsewhere[1].\n\nfn1. Down here, in fact.\n\nfn2. Here is another footnote.') assert re.search(r'^\tThis is covered elsewhere1.
\n\n\t1 Down here, in fact.
\n\n\t2 Here is another footnote.
$', html) is not None html = textile.textile('''See[1] for details -- or perhaps[100] at a push.\n\nfn1. Here are the details.\n\nfn100(footy#otherid). A totally unrelated footnote.''') assert re.search(r'^\tSee1 for details — or perhaps100 at a push.
\n\n\t1 Here are the details.
\n\n\t100 A totally unrelated footnote.
$', html) is not None html = textile.textile('''See[2] for details, and later, reference it again[2].\n\nfn2^(footy#otherid)[en]. Here are the details.''') assert re.search(r'^\tSee2 for details, and later, reference it again2.
\n\n\t2 Here are the details.
$', html) is not None html = textile.textile('''See[3!] for details.\n\nfn3. Here are the details.''') assert re.search(r'^\tSee3 for details.
\n\n\t3 Here are the details.
$', html) is not None html = textile.textile('''See[4!] for details.\n\nfn4^. Here are the details.''') assert re.search(r'^\tSee4 for details.
\n\n\t4 Here are the details.
$', html) is not None def test_issue_35(): result = textile.textile('"z"') expect = '\t“z”
' assert result == expect result = textile.textile('" z"') expect = '\t“ z”
' assert result == expect def test_restricted(): #Note that the HTML is escaped, thus rendering the " result = textile.textile_restricted(test) expect = "\tHere is some text.
\n<script>alert(‘hello world’)</script>
Here’s some <!— commented out —> text.
" assert result == expect test = "p[fr]. Partir, c'est toujours mourir un peu." result = textile.textile_restricted(test) expect = '\tPartir, c’est toujours mourir un peu.
' assert result == expect def test_unicode_footnote(): html = textile.textile('текст[1]') assert re.compile(r'^\tтекст1
$', re.U).search(html) is not None def test_autolinking(): test = """some text "test":http://www.google.com http://www.google.com "$":http://www.google.com""" result = """\tsome text test http://www.google.com www.google.com
""" expect = textile.textile(test) assert result == expect def test_sanitize(): test = "a paragraph of benign text" result = "\ta paragraph of benign text
" try: expect = textile.Textile().parse(test, sanitize=True) assert result == expect test = """a paragraph of evil text
""" result = 'a paragraph of evil text
' expect = textile.Textile().parse(test, sanitize=True) assert result == expect test = """a paragraph of benign text
and more text
a paragraph of benign text
\nand more text
Scientists say the moon is slowly shrinking1.
\n\n\tTim Berners-Lee is one of the pioneer voices in favour of Net Neutrality1 and has expressed the view that ISPs should supply “connectivity with no strings attached”1 2
\n\n\tBerners-Lee admitted that the forward slashes \(“//”\) in a web address were actually unnecessary. He told the newspaper that he could easily have designed URLs not to have the forward slashes. “… it seemed like a good idea at the time,”3
\n\n\tScientists say1 the moon is quite small. But I, for one, don’t believe them. Others claim it to be made of cheese2. If this proves true I suspect we are in for troubled times3 as people argue over their “share” of the moon’s cheese. In the end, its limited size1 may prove problematic.
\n\n\tScientists say1 the moon is quite small. But I, for one, don’t believe them. Others claim it to be made of cheese2. If this proves true I suspect we are in for troubled times3 as people argue over their “share” of the moon’s cheese. In the end, its limited size1 may prove problematic.
\n\n\tScientists say the moon is slowly shrinking1.
\n\n\tSee2 for details, and later, reference it again2.
\n\n\t2 Here are the details.
$' assert re.compile(searchstring).search(html) is not None def test_footnote_without_reflink(): html = textile.textile('''See[3!] for details.\n\nfn3. Here are the details.''') searchstring = r'^\tSee3 for details.
\n\n\t3 Here are the details.
$' assert re.compile(searchstring).search(html) is not None def testSquareBrackets(): html = textile.textile("""1[^st^], 2[^nd^], 3[^rd^]. 2 log[~n~]\n\nA close[!http://textpattern.com/favicon.ico!]image.\nA tight["text":http://textpattern.com/]link.\nA ["footnoted link":http://textpattern.com/][182].""") searchstring = r'^\t1st, 2nd, 3rd. 2 logn
\n\n\tA closeimage.
\nA tighttextlink.
\nA footnoted link182.
We use CSS.
' expect = textile.textile(test, html_type="html5") assert result == expect def test_relURL(): t = textile.Textile() t.restricted = True assert t.relURL("gopher://gopher.com/") == '#' python-textile-2.3.5/tests/test_textilefactory.py 0000664 0000000 0000000 00000001751 13004416251 0022337 0 ustar 00root root 0000000 0000000 from textile import textilefactory import pytest def test_TextileFactory(): f = textilefactory.TextileFactory() result = f.process("some text here") expect = '\tsome text here
' assert result == expect f = textilefactory.TextileFactory(restricted=True) result = f.process("more text here") expect = '\tmore text here
' assert result == expect f = textilefactory.TextileFactory(noimage=True) result = f.process("this covers a partial branch.") expect = '\tthis covers a partial branch.
' assert result == expect # Certain parameter values are not permitted because they are illogical: with pytest.raises(ValueError) as ve: f = textilefactory.TextileFactory(lite=True) assert 'lite can only be enabled in restricted mode' in str(ve.value) with pytest.raises(ValueError) as ve: f = textilefactory.TextileFactory(html_type='invalid') assert "html_type must be 'xhtml' or 'html5'" in str(ve.value) python-textile-2.3.5/tests/test_urls.py 0000664 0000000 0000000 00000003303 13004416251 0020251 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*- from textile import Textile import re def test_urls(): t = Textile() assert t.relURL("http://www.google.com/") == 'http://www.google.com/' result = t.links('fooobar "Google":http://google.com/foobar/ and hello world "flickr":http://flickr.com/photos/jsamsa/ ') expect = 'fooobar {0}2:shelve and hello world {0}4:shelve '.format(t.uid) assert result == expect result = t.links('""Open the door, HAL!"":https://xkcd.com/375/') expect = '{0}6:shelve'.format(t.uid) assert result == expect result = t.links('"$":http://domain.tld/test_[brackets]') expect = '{0}8:shelve'.format(t.uid) assert result == expect result = t.links('"$":http://domain.tld/test_') expect = '{0}10:shelve'.format(t.uid) assert result == expect expect = '"":test' result = t.links(expect) assert result == expect expect = '"$":htt://domain.tld' result = t.links(expect) assert result == expect result = t.shelveURL('') expect = '' assert result == expect result = t.retrieveURLs('{0}2:url'.format(t.uid)) expect = '' assert result == expect result = t.encode_url('http://domain.tld/übermensch') expect = 'http://domain.tld/%C3%BCbermensch' assert result == expect result = t.parse('A link that starts with an h is "handled":/test/ incorrectly.') expect = '\tA link that starts with an h is handled incorrectly.
' assert result == expect def test_rel_attribute(): t = Textile(rel='nofollow') result = t.parse('"$":http://domain.tld') expect = '\t' assert result == expect python-textile-2.3.5/tests/test_utils.py 0000664 0000000 0000000 00000002136 13004416251 0020427 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*- from __future__ import unicode_literals from textile import utils def test_encode_html(): result = utils.encode_html('''this is a "test" of text that's safe to ''' 'put in an attribute.') expect = ('this is a "test" of text that's safe to put in ' 'an <html> attribute.') assert result == expect def test_has_raw_text(): assert utils.has_raw_text('foo bar biz baz
') is False assert utils.has_raw_text(' why yes, yes it does') is True def test_is_rel_url(): assert utils.is_rel_url("http://www.google.com/") is False assert utils.is_rel_url("/foo") is True def test_generate_tag(): result = utils.generate_tag('span', 'inner text', {'class': 'test'}) expect = 'inner text' assert result == expect text = 'Übermensch' attributes = {'href': 'http://de.wikipedia.org/wiki/%C3%C9bermensch'} expect = 'Übermensch' result = utils.generate_tag('a', text, attributes) assert result == expect python-textile-2.3.5/tests/test_values.py 0000664 0000000 0000000 00000077735 13004416251 0020607 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*- from __future__ import unicode_literals import textile import pytest xhtml_known_values = ( ('hello, world', '\thello, world
'), ('A single paragraph.\n\nFollowed by another.', '\tA single paragraph.
\n\n\tFollowed by another.
'), ('I am very serious.\n\n\nI am very serious.\n', '\t
I am very serious.
\n\n\nI am <b>very</b> serious.\n'), ('I spoke.\nAnd none replied.', '\t
I spoke.
\nAnd none replied.
“Observe!”
'), ('Observe -- very nice!', '\tObserve — very nice!
'), ('Observe - tiny and brief.', '\tObserve – tiny and brief.
'), ('Observe...', '\tObserve…
'), ('Observe ...', '\tObserve …
'), ('Observe: 2 x 2.', '\tObserve: 2 × 2.
'), ('one(TM), two(R), three(C).', '\tone™, two®, three©.
'), ('h1. Header 1', '\tAn old text
\n\n\t\n\t\t\n\n\tA block quotation.
\n\t
Any old text
'), ('I _believe_ every word.', '\tI believe every word.
'), ('And then? She *fell*!', '\tAnd then? She fell!
'), ('I __know__.\nI **really** __know__.', '\tI know.
\nI really know.
Cat’s Cradle by Vonnegut
'), ('Convert with @str(foo)@', '\tConvert with str(foo)
I’m sure not sure.
You are a pleasant child.
'), ('a ^2^ + b ^2^ = c ^2^', '\ta 2 + b 2 = c 2
'), ('log ~2~ x', '\tlog 2 x
'), ('I\'m %unaware% of most soft drinks.', '\tI’m unaware of most soft drinks.
'), ("I'm %{color:red}unaware%\nof most soft drinks.", '\tI’m unaware
\nof most soft drinks.
An example
'), ('p(#big-red). Red here', '\tRed here
'), ('p(example1#big-red2). Red here', '\tRed here
'), ('p{color:blue;margin:30px}. Spacey blue', '\tSpacey blue
'), ('p[fr]. rouge', '\trouge
'), ('I seriously *{color:red}blushed*\nwhen I _(big)sprouted_ that\ncorn stalk from my\n%[es]cabeza%.', '\tI seriously blushed
\nwhen I sprouted'
' that
\ncorn stalk from my
\ncabeza.
align left
'), ('p>. align right', '\talign right
'), ('p=. centered', '\tcentered
'), ('p<>. justified', '\tjustified
'), ('p(. left ident 1em', '\tleft ident 1em
'), ('p((. left ident 2em', '\tleft ident 2em
'), ('p))). right ident 3em', '\tright ident 3em
'), ('h2()>. Bingo.', '\t\n\na.gsub!( /\n',
'\n\na.gsub!( /</, "" )\n\n'),
('The main text of the
\n'
'page goes here and will
\nstay to the left of the
\nsidebar.
I searched Google.
'), ('I searched "a search engine (Google)":http://google.com.', '\tI searched a search engine.
'), ('I am crazy about "Hobix":hobix\nand "it\'s":hobix "all":hobix I ever\n"link to":hobix!\n\n[hobix]http://hobix.com', '\tI am crazy about Hobix
\nand it’s '
'all I ever
\nlink to!
And others sat all round the small
\nmachine and paid it to sing to them.
We use CSS.
'), ('|one|two|three|\n|a|b|c|', '\t| one | \n\t\t\ttwo | \n\t\t\tthree | \n\t\t
| a | \n\t\t\tb | \n\t\t\tc | \n\t\t
| name | \n\t\t\tage | \n\t\t\tsex | \n\t\t
| joan | \n\t\t\t24 | \n\t\t\tf | \n\t\t
| archie | \n\t\t\t29 | \n\t\t\tm | \n\t\t
| bella | \n\t\t\t45 | \n\t\t\tf | \n\t\t
| name | \n\t\t\tage | \n\t\t\tsex | \n\t\t
|---|---|---|
| joan | \n\t\t\t24 | \n\t\t\tf | \n\t\t
| archie | \n\t\t\t29 | \n\t\t\tm | \n\t\t
| bella | \n\t\t\t45 | \n\t\t\tf | \n\t\t
Hello\n\nHello Again\n\n\t
normal text
'), ('this is in a pre tag', '
this is in a pre tag'), ('"test1":http://foo.com/bar--baz\n\n"test2":http://foo.com/bar---baz\n\n"test3":http://foo.com/bar-17-18-baz', '\t\n\n\t' '\n\n\t' ''), ('"foo ==(bar)==":#foobar', '\t'), ('!http://render.mathim.com/A%5EtAx%20%3D%20A%5Et%28Ax%29.!', '\t
array[4] = 8
Links (like this), are now mangled in 2.1.0, whereas 2.0 parsed them correctly.
'), ('@monospaced text@, followed by text', '\tmonospaced text, followed by text
some text
'), ('pre.. foo bar baz\nquux', 'foo bar baz\nquux'), ('line of text\n\n leading spaces', '\t
line of text
\n\n leading spaces'), ('"some text":http://www.example.com/?q=foo%20bar and more text', '\tsome text and more text
'), ('(??some text??)', '\t(some text)
'), ('(*bold text*)', '\t(bold text)
'), ('H[~2~]O', '\tH2O
'), ("p=. Où est l'école, l'église s'il vous plaît?", """\tOù est l’école, l’église s’il vous plaît?
"""), ("p=. *_The_* _*Prisoner*_", """\tThe Prisoner
"""), ("""p=. "An emphasised _word._" & "*A spanned phrase.*" """, """\t“An emphasised word.” & “A spanned phrase.”
"""), ("""p=. "*Here*'s a word!" """, """\t“Here’s a word!”
"""), ("""p=. "Please visit our "Textile Test Page":http://textile.sitemonks.com" """, """\t“Please visit our Textile Test Page”
"""), ("""| Foreign EXPÓŅÉNTIAL |""", """\t| Foreign EXPÓŅÉNTIAL | \n\t\t
Piękne ŹDŹBŁO
"""), ("""p=. Tell me, what is AJAX(Asynchronous Javascript and XML), please?""", """\tTell me, what is AJAX, please?
"""), ('p{font-size:0.8em}. *TxStyle* is a documentation project of Textile 2.4 for "Textpattern CMS":http://texpattern.com.', '\tTxStyle is a documentation project of Textile 2.4 for Textpattern CMS.
'), (""""Übermensch":http://de.wikipedia.org/wiki/Übermensch""", """\t"""), ("""Here is some text with a block.\n\n\n\n\n\nbc. """, """\tHere is some text with a block.
\n\n\t\n\n\t\n\n<!-- Here is a comment block in a code block. -->\n“Textile©” is a registered® ‘trademark’ of Textpattern™ — or TXP — at least it was – back in ’88 when 2×4 was ±5°C … QED!
\n\n\t2¼ 3½ 4¾
"""), ("""|=. Testing colgroup and col syntax\n|:\\5. 80\n|a|b|c|d|e|\n\n|=. Testing colgroup and col syntax|\n|:\\5. 80|\n|a|b|c|d|e|""", """\t| a | \n\t\t\tb | \n\t\t\tc | \n\t\t\td | \n\t\t\te | \n\t\t
| a | \n\t\t\tb | \n\t\t\tc | \n\t\t\td | \n\t\t\te | \n\t\t
| Title | \n\t\t\tStarring | \n\t\t\tDirector | \n\t\t\tWriter | \n\t\t\tNotes | \n\t\t
|---|---|---|---|---|
| This is the tfoot, centred | \n\t\t||||
| The Usual Suspects | \n\t\t\tBenicio Del Toro, Gabriel Byrne, Stephen Baldwin, Kevin Spacey | \n\t\t\tBryan Singer | \n\t\t\tChris McQaurrie | \n\t\t\tOne of the finest films ever made | \n\t\t
| Se7en | \n\t\t\tMorgan Freeman, Brad Pitt, Kevin Spacey | \n\t\t\tDavid Fincher | \n\t\t\tAndrew Kevin Walker | \n\t\t\tGreat psychological thriller | \n\t\t
| Primer | \n\t\t\tDavid Sullivan, Shane Carruth | \n\t\t\tShane Carruth | \n\t\t\tShane Carruth | \n\t\t\t Amazing insight into trust and human psychology \nrather than science fiction. Terrific! | \n\t\t
| District 9 | \n\t\t\tSharlto Copley, Jason Cope | \n\t\t\tNeill Blomkamp | \n\t\t\tNeill Blomkamp, Terri Tatchell | \n\t\t\t Social commentary layered on thick, \nbut boy is it done well | \n\t\t
| Arlington Road | \n\t\t\tTim Robbins, Jeff Bridges | \n\t\t\tMark Pellington | \n\t\t\tEhren Kruger | \n\t\t\tAwesome study in neighbourly relations | \n\t\t
| Phone Booth | \n\t\t\tColin Farrell, Kiefer Sutherland, Forest Whitaker | \n\t\t\tJoel Schumacher | \n\t\t\tLarry Cohen | \n\t\t\t Edge-of-the-seat stuff in this \nshort but brilliantly executed thriller | \n\t\t
Nourishing beverage for baby cows.
\nCold drink that goes great with cookies.
Here is a comment
\n\n\tHere is a comment
\n\n\tHere is a class that is a little extended and is
\nfollowed by a strong word!
; Content-type: text/javascript\n; Cache-Control: no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0\n; Expires: Sat, 24 Jul 2003 05:00:00 GMT\n; Last-Modified: Wed, 1 Jan 2025 05:00:00 GMT\n; Pragma: no-cache\n123 test
\n\n\ttest 123
\n\n\t123 test
\n\n\ttest 123
"""), ("""#_(first#list) one\n# two\n# three\n\ntest\n\n#(ordered#list2).\n# one\n# two\n# three\n\ntest\n\n#_(class_4).\n# four\n# five\n# six\n\ntest\n\n#_ seven\n# eight\n# nine\n\ntest\n\n# one\n# two\n# three\n\ntest\n\n#22 22\n# 23\n# 24""", """\ttest
\n\n\ttest
\n\n\ttest
\n\n\ttest
\n\n\ttest
\n\n\ttest
\n\n\ttest
\n\n\t\t
| \n\t\t
\t
| \n\t\t
\n | \n\t\t
| table | \n\t\t\tmore | \n\t\t\tbadass | \n\t\t
|---|---|---|
| Horizontal span of 3 | \n\t\t||
| first | \n\t\t\tHAL | \n\t\t\t1 | \n\t\t
| some | \n\t\t\tstyled | \n\t\t\tcontent | \n\t\t
| spans 2 rows | \n\t\t\tthis is | \n\t\t\tquite a | \n\t\t
| deep test | \n\t\t\tdon’t you think? | \n\t\t|
| fifth | \n\t\t\tI’m a lumberjack | \n\t\t\t5 | \n\t\t
| sixth | \n\t\t\tbold italics | \n\t\t\t6 | \n\t\t
| strong | \n\t\t
| em | \n\t\t
| Inter-word | \n\t\t\tZIP-codes are 5- or 9-digit codes | \n\t\t
| attribute list | \n\t\t
|---|
| align left | \n\t\t
| align right | \n\t\t
| center | \n\t\t
| justify me | \n\t\t
| valign top | \n\t\t
| bottom | \n\t\t
Goodbye.
"""), ("""h2. A Definition list which covers the instance where a new definition list is created with a term without a definition\n\n- term :=\n- term2 := def""", """\t& test
'), ) # A few extra cases for HTML4 html_known_values = ( ('I spoke.\nAnd none replied.', '\tI spoke.
\nAnd none replied.
I know.
\nI really know.
I’m unaware
\nof most soft drinks.
I seriously blushed
\nwhen I sprouted'
' that
\ncorn stalk from my
\ncabeza.
\n\na.gsub!( /\n',
'\n\na.gsub!( /</, "" )\n\n'),
('The main text of the
\n'
'page goes here and will
\nstay to the left of the
\nsidebar.
I am crazy about Hobix
\nand it’s '
'all I ever
\nlink to!
And others sat all round the small
\nmachine and paid it to sing to them.
quux
'), ('"foo":http://google.com/one--two', '\t'), # issue 24 colspan ('|\\2. spans two cols |\n| col 1 | col 2 |', '\t| spans two cols | \n\t\t|
| col 1 | \n\t\t\tcol 2 | \n\t\t
Hello\n\nAgain\n\n\t
normal text
'), # url with parentheses ('"python":http://en.wikipedia.org/wiki/Python_(programming_language)', '\t'), # table with hyphen styles ('table(linkblog-thumbnail).\n|(linkblog-thumbnail-cell). apple|bear|', '\t| apple | \n\t\t\tbear | \n\t\t
| thing | \n\t\t\t\n\t\t\t | \n\t\t\t | otherthing | \n\t\t
test text
"), ("_*test text*_", "\ttest text
"), # quotes in code block ("'quoted string'", "\t'quoted string'
some preformatted textother text", "\t
some preformatted textother text"), # at sign and notextile in table ("|@
<A1> | \n\t\t\t<A2> <A3> | \n\t\t
| *B1* | \n\t\t\t*B2* *B3* | \n\t\t
\n\t\t'), ('Hello ["(Mum) & dad"]', '\tText…
\n\t
Hello [“(Mum) & dad”]
'), ) @pytest.mark.parametrize("input, expected_output", xhtml_known_values) def test_KnownValuesXHTML(input, expected_output): # XHTML output = textile.textile(input, html_type='xhtml') assert output == expected_output @pytest.mark.parametrize("input, expected_output", html_known_values) def test_KnownValuesHTML(input, expected_output): # HTML5 output = textile.textile(input, html_type='html5') assert output == expected_output python-textile-2.3.5/textile/ 0000775 0000000 0000000 00000000000 13004416251 0016170 5 ustar 00root root 0000000 0000000 python-textile-2.3.5/textile/__init__.py 0000664 0000000 0000000 00000000753 13004416251 0020306 0 ustar 00root root 0000000 0000000 from __future__ import unicode_literals import sys import warnings from .core import textile, textile_restricted, Textile from .version import VERSION __all__ = ['textile', 'textile_restricted'] __version__ = VERSION if sys.version_info[:2] == (2, 6): warnings.warn( "Python 2.6 is no longer supported by the Python core team, please " "upgrade your Python. A future version of textile will drop support " "for Python 2.6", DeprecationWarning ) python-textile-2.3.5/textile/__main__.py 0000664 0000000 0000000 00000002300 13004416251 0020255 0 ustar 00root root 0000000 0000000 import argparse import sys import textile def main(): """A CLI tool in the style of python's json.tool. In fact, this is mostly copied directly from that module. This allows us to create a stand-alone tool as well as invoking it via `python -m textile`.""" prog = 'textile' description = ('A simple command line interface for textile module ' 'to convert textile input to HTML output. This script ' 'accepts input as a file or stdin and can write out to ' 'a file or stdout.') parser = argparse.ArgumentParser(prog=prog, description=description) parser.add_argument('infile', nargs='?', type=argparse.FileType(), help='a textile file to be converted') parser.add_argument('outfile', nargs='?', type=argparse.FileType('w'), help='write the output of infile to outfile') options = parser.parse_args() infile = options.infile or sys.stdin outfile = options.outfile or sys.stdout with infile: output = textile.textile(''.join(infile.readlines())) with outfile: outfile.write(output) if __name__ == '__main__': #pragma: no cover main() python-textile-2.3.5/textile/core.py 0000664 0000000 0000000 00000152550 13004416251 0017502 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*- from __future__ import unicode_literals __copyright__ = """ Copyright (c) 2009, Jason Samsa, http://jsamsa.com/ Copyright (c) 2010, Kurt Raschke\[)? # Optionally open with a square bracket eg. Look ["here":url]
{0}linkStartMarker:" # marks start of the link
(?P(?:.|\n)*?) # grab the content of the inner "..." part of the link, can be anything but
# do not worry about matching class, id, lang or title yet
": # literal ": marks end of atts + text + title block
(?P[^{1}]*) # url upto a stopchar
""".format(self.uid, stopchars)
text = re.compile(pattern, flags=re.X | re.U).sub(self.fLink, text)
return text
def fLink(self, m):
in_ = m.group()
pre, inner, url = m.groups()
pre = pre or ''
if inner == '':
return '{0}"{1}":{2}'.format(pre, inner, url)
m = re.search(r'''^
(?P{0}) # $atts (if any)
{1}* # any optional spaces
(?P # $text is...
(!.+!) # an image
| # else...
.+? # link text
) # end of $text
(?:\((?P[^)]+?)\))? # $title (if any)
$'''.format(cls_re_s, regex_snippets['space']), inner,
flags=re.X | re.U)
atts = m.group('atts') or ''
text = m.group('text') or '' or inner
title = m.group('title') or ''
pop, tight = '', ''
counts = { '[': None, ']': url.count(']'), '(': None, ')': None }
# Look for footnotes or other square-bracket delimited stuff at the end
# of the url...
#
# eg. "text":url][otherstuff... will have "[otherstuff" popped back
# out.
#
# "text":url?q[]=x][123] will have "[123]" popped off the back, the
# remaining closing square brackets will later be tested for balance
if (counts[']']):
m = re.search('(?P<url>^.*\])(?P<tight>\[.*?)$', url, flags=re.U)
if m:
url, tight = m.groups()
# Split off any trailing text that isn't part of an array assignment.
# eg. "text":...?q[]=value1&q[]=value2 ... is ok
# "text":...?q[]=value1]following ... would have "following" popped
# back out and the remaining square bracket will later be tested for
# balance
if (counts[']']):
m = re.search(r'(?P<url>^.*\])(?!=)(?P<end>.*?)$', url, flags=re.U)
url = m.group('url')
tight = '{0}{1}'.format(m.group('end'), tight)
# Now we have the array of all the multi-byte chars in the url we will
# parse the uri backwards and pop off any chars that don't belong
# there (like . or , or unmatched brackets of various kinds).
first = True
popped = True
counts[']'] = url.count(']')
url_chars = list(url)
def _endchar(c, pop, popped, url_chars, counts, pre):
"""Textile URL shouldn't end in these characters, we pop them off
the end and push them out the back of the url again."""
pop = '{0}{1}'.format(c, pop)
url_chars.pop()
popped = True
return pop, popped, url_chars, counts, pre
def _rightanglebracket(c, pop, popped, url_chars, counts, pre):
url_chars.pop()
urlLeft = ''.join(url_chars)
m = re.search(r'(?P<url_chars>.*)(?P<tag><\/[a-z]+)$', urlLeft)
url_chars = m.group('url_chars')
pop = '{0}{1}{2}'.format(m.group('tag'), c, pop)
popped = True
return pop, popped, url_chars, counts, pre
def _closingsquarebracket(c, pop, popped, url_chars, counts, pre):
"""If we find a closing square bracket we are going to see if it is
balanced. If it is balanced with matching opening bracket then it
is part of the URL else we spit it back out of the URL."""
# If counts['['] is None, count the occurrences of '['
counts['['] = counts['['] or url.count('[')
if counts['['] == counts[']']:
# It is balanced, so keep it
url_chars.append(c)
else:
# In the case of un-matched closing square brackets we just eat
# it
popped = True
url_chars.pop()
counts[']'] = counts[']'] - 1;
if first: # pragma: no branch
pre = ''
return pop, popped, url_chars, counts, pre
def _closingparenthesis(c, pop, popped, url_chars, counts, pre):
if counts[')'] is None: # pragma: no branch
counts['('] = url.count('(')
counts[')'] = url.count(')')
if counts['('] != counts[')']:
# Unbalanced so spit it out the back end
popped = True
pop = '{0}{1}'.format(url_chars.pop(), pop)
counts[')'] = counts[')'] - 1
return pop, popped, url_chars, counts, pre
def _casesdefault(c, pop, popped, url_chars, counts, pre):
return pop, popped, url_chars, counts, pre
cases = {
'!': _endchar,
'?': _endchar,
':': _endchar,
';': _endchar,
'.': _endchar,
',': _endchar,
'>': _rightanglebracket,
']': _closingsquarebracket,
')': _closingparenthesis,
}
for c in url_chars[-1::-1]: # pragma: no branch
popped = False
pop, popped, url_chars, counts, pre = cases.get(c,
_casesdefault)(c, pop, popped, url_chars, counts, pre)
first = False
if popped is False:
break
url = ''.join(url_chars)
uri_parts = urlsplit(url)
scheme_in_list = uri_parts.scheme in self.url_schemes
valid_scheme = (uri_parts.scheme and scheme_in_list)
if not is_valid_url(url) and not valid_scheme:
return in_.replace('{0}linkStartMarker:'.format(self.uid), '')
if text == '$':
text = url
if "://" in text:
text = text.split("://")[1]
else:
text = text.split(":")[1]
text = text.strip()
title = encode_html(title)
if not self.noimage: # pragma: no branch
text = self.image(text)
text = self.span(text)
text = self.glyphs(text)
url = self.shelveURL(self.encode_url(urlunsplit(uri_parts)))
attributes = parse_attributes(atts)
if title:
# if the title contains unicode data, it is annoying to get Python
# 2.6 and all the latter versions working properly. But shelving
# the title is a quick and dirty solution.
attributes['title'] = self.shelve(title)
attributes['href'] = url
if self.rel:
attributes['rel'] = self.rel
a_text = generate_tag('a', text, attributes)
a_shelf_id = self.shelve(a_text)
out = '{0}{1}{2}{3}'.format(pre, a_shelf_id, pop, tight)
return out
def encode_url(self, url):
"""
Converts a (unicode) URL to an ASCII URL, with the domain part
IDNA-encoded and the path part %-encoded (as per RFC 3986).
Fixed version of the following code fragment from Stack Overflow:
http://stackoverflow.com/a/804380/72656
"""
# turn string into unicode
if not isinstance(url, six.text_type):
url = url.decode('utf8')
# parse it
parsed = urlsplit(url)
if parsed.netloc:
# divide the netloc further
netloc_pattern = re.compile(r"""
(?:(?P<user>[^:@]+)(?::(?P<password>[^:@]+))?@)?
(?P<host>[^:]+)
(?::(?P<port>[0-9]+))?
""", re.X | re.U)
netloc_parsed = netloc_pattern.match(parsed.netloc).groupdict()
else:
netloc_parsed = {'user': '', 'password': '', 'host': '', 'port':
''}
# encode each component
scheme = parsed.scheme
user = netloc_parsed['user'] and quote(netloc_parsed['user'])
password = (netloc_parsed['password'] and
quote(netloc_parsed['password']))
host = netloc_parsed['host']
port = netloc_parsed['port'] and netloc_parsed['port']
path = '/'.join( # could be encoded slashes!
quote(unquote(pce).encode('utf8'), b'')
for pce in parsed.path.split('/')
)
fragment = quote(unquote(parsed.fragment))
# put it back together
netloc = ''
if user:
netloc = '{0}{1}'.format(netloc, user)
if password:
netloc = '{0}:{1}'.format(netloc, password)
netloc = '{0}@'.format(netloc)
netloc = '{0}{1}'.format(netloc, host)
if port:
netloc = '{0}:{1}'.format(netloc, port)
return urlunsplit((scheme, netloc, path, parsed.query, fragment))
def span(self, text):
qtags = (r'\*\*', r'\*', r'\?\?', r'\-', r'__',
r'_', r'%', r'\+', r'~', r'\^')
pnct = r""".,"'?!;:‹›«»„“”‚‘’"""
self.span_depth = self.span_depth + 1
if self.span_depth <= self.max_span_depth:
for tag in qtags:
pattern = re.compile(r"""
(?P<pre>^|(?<=[\s>{pnct}\(])|[{{[])
(?P<tag>{tag})(?!{tag})
(?P<atts>{cls})
(?!{tag})
(?::(?P<cite>\S+[^{tag}]{space}))?
(?P<content>[^{space}{tag}]+|\S.*?[^\s{tag}\n])
(?P<end>[{pnct}]*)
{tag}
(?P<tail>$|[\[\]}}<]|(?=[{pnct}]{{1,2}}[^0-9]|\s|\)))
""".format(**{'tag': tag, 'cls': cls_re_s, 'pnct': pnct,
'space': regex_snippets['space']}), flags=re.X | re.U)
text = pattern.sub(self.fSpan, text)
self.span_depth = self.span_depth - 1
return text
def fSpan(self, match):
pre, tag, atts, cite, content, end, tail = match.groups()
qtags = {
'*': 'strong',
'**': 'b',
'??': 'cite',
'_': 'em',
'__': 'i',
'-': 'del',
'%': 'span',
'+': 'ins',
'~': 'sub',
'^': 'sup'
}
tag = qtags[tag]
atts = pba(atts)
if cite:
atts = '{0} cite="{1}"'.format(atts, cite.rstrip())
content = self.span(content)
out = "<{0}{1}>{2}{3}</{4}>".format(tag, atts, content, end, tag)
if pre and not tail or tail and not pre:
out = '{0}{1}{2}'.format(pre, out, tail)
return out
def image(self, text):
pattern = re.compile(r"""
(?:[\[{{])? # pre
\! # opening !
(\<|\=|\>)? # optional alignment atts
({0}) # optional style,class atts
(?:\. )? # optional dot-space
([^\s(!]+) # presume this is the src
\s? # optional space
(?:\(([^\)]+)\))? # optional title
\! # closing
(?::(\S+))? # optional href
(?:[\]}}]|(?=\s|$)) # lookahead: space or end of string
""".format(cls_re_s), re.U | re.X)
return pattern.sub(self.fImage, text)
def fImage(self, match):
# (None, '', '/imgs/myphoto.jpg', None, None)
align, attributes, url, title, href = match.groups()
atts = OrderedDict()
size = None
alignments = {'<': 'left', '=': 'center', '>': 'right'}
if not title:
title = ''
if not is_rel_url(url) and self.get_sizes:
size = imagesize.getimagesize(url)
if href:
href = self.shelveURL(href)
url = self.shelveURL(url)
if align:
atts.update(align=alignments[align])
atts.update(alt=title)
if size:
atts.update(height=six.text_type(size[1]))
atts.update(src=url)
if attributes:
atts.update(parse_attributes(attributes))
if title:
atts.update(title=title)
if size:
atts.update(width=six.text_type(size[0]))
img = generate_tag('img', ' /', atts)
if href:
a_atts = OrderedDict(href=href)
if self.rel:
a_atts.update(rel=self.rel)
img = generate_tag('a', img, a_atts)
return img
def code(self, text):
text = self.doSpecial(text, '<code>', '</code>', self.fCode)
text = self.doSpecial(text, '@', '@', self.fCode)
text = self.doSpecial(text, '<pre>', '</pre>', self.fPre)
return text
def fCode(self, match):
before, text, after = match.groups()
after = after or ''
# text needs to be escaped
text = encode_html(text, quotes=False)
return ''.join([before, self.shelve('<code>{0}</code>'.format(text)), after])
def fPre(self, match):
before, text, after = match.groups()
if after is None:
after = ''
# text needs to be escaped
text = encode_html(text)
return ''.join([before, '<pre>', self.shelve(text), '</pre>', after])
def doSpecial(self, text, start, end, method):
pattern = re.compile(r'(^|\s|[\[({{>|]){0}(.*?){1}($|[\])}}])?'.format(
re.escape(start), re.escape(end)), re.M | re.S)
return pattern.sub(method, text)
def noTextile(self, text):
text = self.doSpecial(text, '<notextile>', '</notextile>',
self.fTextile)
return self.doSpecial(text, '==', '==', self.fTextile)
def fTextile(self, match):
before, notextile, after = match.groups()
if after is None: # pragma: no branch
after = ''
return ''.join([before, self.shelve(notextile), after])
def getHTMLComments(self, text):
"""Search the string for HTML comments, e.g. <!-- comment text -->. We
send the text that matches this to fParseHTMLComments."""
return self.doSpecial(text, '<!--', '-->', self.fParseHTMLComments)
def fParseHTMLComments(self, match):
"""If self.restricted is True, clean the matched contents of the HTML
comment. Otherwise, return the comments unchanged.
The original php had an if statement in here regarding restricted mode.
nose reported that this line wasn't covered. It's correct. In
restricted mode, the html comment tags have already been converted to
<!*#8212; and —> so they don't match in getHTMLComments,
and never arrive here.
"""
before, commenttext, after = match.groups()
commenttext = self.shelve(commenttext)
return '{0}<!--{1}-->'.format(before, commenttext)
def redcloth_list(self, text):
"""Parse the text for definition lists and send them to be
formatted."""
pattern = re.compile(r"^([-]+{0}[ .].*:=.*)$(?![^-])".format(cls_re_s),
re.M | re.U | re.S)
return pattern.sub(self.fRCList, text)
def fRCList(self, match):
"""Format a definition list."""
out = []
text = re.split(r'\n(?=[-])', match.group(), flags=re.M)
for line in text:
# parse the attributes and content
m = re.match(r'^[-]+({0})[ .](.*)$'.format(cls_re_s), line,
flags=re.M | re.S)
atts, content = m.groups()
# cleanup
content = content.strip()
atts = pba(atts)
# split the content into the term and definition
xm = re.match(r'^(.*?)[\s]*:=(.*?)[\s]*(=:|:=)?[\s]*$', content,
re.S)
term, definition, ending = xm.groups()
# cleanup
term = term.strip()
definition = definition.strip(' ')
# if this is the first time through, out as a bool is False
if not out:
if definition == '':
dltag = "<dl{0}>".format(atts)
else:
dltag = "<dl>"
out.append(dltag)
if definition != '' and term != '':
if definition.startswith('\n'):
definition = '<p>{0}</p>'.format(definition.lstrip())
definition = definition.replace('\n', '<br />').strip()
term = self.graf(term)
definition = self.graf(definition)
out.extend(['\t<dt{0}>{1}</dt>'.format(atts, term),
'\t<dd>{0}</dd>'.format(definition)])
out.append('</dl>')
out = '\n'.join(out)
return out
def placeNoteLists(self, text):
"""Parse the text for endnotes."""
if self.notes:
o = OrderedDict()
for label, info in self.notes.items():
if 'seq' in info:
i = info['seq']
info['seq'] = label
o[i] = info
else:
self.unreferencedNotes[label] = info
if o: # pragma: no branch
# sort o by key
o = OrderedDict(sorted(o.items(), key=lambda t: t[0]))
self.notes = o
text_re = re.compile('<p>notelist({0})(?:\:([\w|{1}]))?([\^!]?)(\+?)'
'\.?[\s]*</p>'.format(cls_re_s, syms_re_s), re.U)
text = text_re.sub(self.fNoteLists, text)
return text
def fNoteLists(self, match):
"""Given the text that matches as a note, format it into HTML."""
att, start_char, g_links, extras = match.groups()
start_char = start_char or 'a'
index = '{0}{1}{2}'.format(g_links, extras, start_char)
result = ''
if index not in self.notelist_cache: # pragma: no branch
o = []
if self.notes: # pragma: no branch
for seq, info in self.notes.items():
links = self.makeBackrefLink(info, g_links, start_char)
atts = ''
if 'def' in info:
infoid = info['id']
atts = info['def']['atts']
content = info['def']['content']
li = ('\t\t<li{0}>{1}<span id="note{2}"> '
'</span>{3}</li>').format(atts, links, infoid,
content)
else:
li = ('\t\t<li{0}>{1} Undefined Note [#{2}].<li>'
).format(atts, links, info['seq'])
o.append(li)
if '+' == extras and self.unreferencedNotes:
for seq, info in self.unreferencedNotes.items():
atts = info['def']['atts']
content = info['def']['content']
li = '\t\t<li{0}>{1}</li>'.format(atts, content)
o.append(li)
self.notelist_cache[index] = "\n".join(o)
result = self.notelist_cache[index]
list_atts = pba(att)
result = '<ol{0}>\n{1}\n\t</ol>'.format(list_atts, result)
return result
def makeBackrefLink(self, info, g_links, i):
"""Given the pieces of a back reference link, create an <a> tag."""
atts, content, infoid, link = '', '', '', ''
if 'def' in info:
link = info['def']['link']
backlink_type = link or g_links
i_ = encode_high(i)
allow_inc = i not in syms_re_s
i_ = int(i_)
if backlink_type == "!":
return ''
elif backlink_type == '^':
return """<sup><a href="#noteref{0}">{1}</a></sup>""".format(
info['refids'][0], i)
else:
result = []
for refid in info['refids']:
i_entity = decode_high(i_)
sup = """<sup><a href="#noteref{0}">{1}</a></sup>""".format(
refid, i_entity)
if allow_inc:
i_ = i_ + 1
result.append(sup)
result = ' '.join(result)
return result
def fParseNoteDefs(self, m):
"""Parse the note definitions and format them as HTML"""
label = m.group('label')
link = m.group('link')
att = m.group('att')
content = m.group('content')
# Assign an id if the note reference parse hasn't found the label yet.
if label not in self.notes:
self.notes[label] = {'id': '{0}{1}'.format(self.linkPrefix,
self._increment_link_index())}
# Ignores subsequent defs using the same label
if 'def' not in self.notes[label]: # pragma: no branch
self.notes[label]['def'] = {'atts': pba(att), 'content':
self.graf(content), 'link': link}
return ''
def noteRef(self, text):
"""Search the text looking for note references."""
text_re = re.compile(r"""
\[ # start
({0}) # !atts
\#
([^\]!]+) # !label
([!]?) # !nolink
\]""".format(cls_re_s), re.X)
text = text_re.sub(self.fParseNoteRefs, text)
return text
def fParseNoteRefs(self, match):
"""Parse and format the matched text into note references.
By the time this function is called, all the defs will have been
processed into the notes array. So now we can resolve the link numbers
in the order we process the refs..."""
atts, label, nolink = match.groups()
atts = pba(atts)
nolink = nolink == '!'
# Assign a sequence number to this reference if there isn't one already
if label in self.notes:
num = self.notes[label]['seq']
else:
self.notes[label] = {
'seq': self.note_index, 'refids': [], 'id': ''
}
num = self.note_index
self.note_index = self.note_index + 1
# Make our anchor point and stash it for possible use in backlinks when
# the note list is generated later...
refid = '{0}{1}'.format(self.linkPrefix, self._increment_link_index())
self.notes[label]['refids'].append(refid)
# If we are referencing a note that hasn't had the definition parsed
# yet, then assign it an ID...
if not self.notes[label]['id']:
self.notes[label]['id'] = '{0}{1}'.format(self.linkPrefix,
self._increment_link_index())
labelid = self.notes[label]['id']
# Build the link (if any)...
result = '<span id="noteref{0}">{1}</span>'.format(refid, num)
if not nolink:
result = '<a href="#note{0}">{1}</a>'.format(labelid, result)
# Build the reference...
result = '<sup{0}>{1}</sup>'.format(atts, result)
return result
def shelveURL(self, text):
if text == '':
return ''
self.refIndex = self.refIndex + 1
self.refCache[self.refIndex] = text
output = '{0}{1}{2}'.format(self.uid, self.refIndex, ':url')
return output
def retrieveURLs(self, text):
return re.sub(r'{0}(?P<token>[0-9]+):url'.format(self.uid), self.retrieveURL, text)
def retrieveURL(self, match):
url = self.refCache.get(int(match.group('token')), '')
if url is '':
return url
if url in self.urlrefs:
url = self.urlrefs[url]
return url
def _increment_link_index(self):
"""The self.linkIndex property needs to be incremented in various
places. Don't Repeat Yourself."""
self.linkIndex = self.linkIndex + 1
return self.linkIndex
def textile(text, html_type='xhtml', encoding=None, output=None):
"""
Apply Textile to a block of text.
This function takes the following additional parameters:
html_type - 'xhtml' or 'html5' style tags (default: 'xhtml')
"""
return Textile(html_type=html_type).parse(text)
def textile_restricted(text, lite=True, noimage=True, html_type='xhtml'):
"""
Apply Textile to a block of text, with restrictions designed for weblog
comments and other untrusted input. Raw HTML is escaped, style attributes
are disabled, and rel='nofollow' is added to external links.
This function takes the following additional parameters:
html_type - 'xhtml' or 'html5' style tags (default: 'xhtml')
lite - restrict block tags to p, bq, and bc, disable tables (default: True)
noimage - disable image tags (default: True)
"""
return Textile(restricted=True, lite=lite, noimage=noimage,
html_type=html_type, rel='nofollow').parse(
text)
python-textile-2.3.5/textile/objects/ 0000775 0000000 0000000 00000000000 13004416251 0017621 5 ustar 00root root 0000000 0000000 python-textile-2.3.5/textile/objects/__init__.py 0000664 0000000 0000000 00000000120 13004416251 0021723 0 ustar 00root root 0000000 0000000 from .block import Block
from .table import Table
__all__ = ['Block', 'Table']
python-textile-2.3.5/textile/objects/block.py 0000664 0000000 0000000 00000010655 13004416251 0021274 0 ustar 00root root 0000000 0000000 try:
from collections import OrderedDict
except ImportError:
from ordereddict import OrderedDict
try:
import regex as re
except ImportError:
import re
from textile.regex_strings import cls_re_s, regex_snippets
from textile.utils import encode_html, generate_tag, parse_attributes
class Block(object):
def __init__(self, textile, tag, atts, ext, cite, content):
self.textile = textile
self.tag = tag
self.atts = atts
self.ext = ext
self.cite = cite
self.content = content
self.attributes = parse_attributes(atts)
self.outer_tag = ''
self.inner_tag = ''
self.outer_atts = OrderedDict()
self.inner_atts = OrderedDict()
self.eat = False
self.process()
def process(self):
if self.tag == 'p':
# is this an anonymous block with a note definition?
notedef_re = re.compile(r"""
^note\# # start of note def marker
(?P<label>[^%<*!@\#^([{{ {space}.]+) # label
(?P<link>[*!^]?) # link
(?P<att>{cls}) # att
\.? # optional period.
[{space}]+ # whitespace ends def marker
(?P<content>.*)$ # content""".format(
space=regex_snippets['space'], cls=cls_re_s),
flags=re.X | re.U)
notedef = notedef_re.sub(self.textile.fParseNoteDefs, self.content)
# It will be empty if the regex matched and ate it.
if '' == notedef:
self.content = notedef
fns = re.search(r'fn(?P<fnid>{0}+)'.format(regex_snippets['digit']),
self.tag, flags=re.U)
if fns:
self.tag = 'p'
fnid = self.textile.fn.get(fns.group('fnid'), None)
if fnid is None:
fnid = '{0}{1}'.format(self.textile.linkPrefix,
self.textile._increment_link_index())
# If there is an author-specified ID goes on the wrapper & the
# auto-id gets pushed to the <sup>
supp_id = OrderedDict()
# if class has not been previously specified, set it to "footnote"
if 'class' not in self.attributes:
self.attributes.update({'class': 'footnote'})
# if there's no specified id, use the generated one.
if 'id' not in self.attributes:
self.attributes.update({'id': 'fn{0}'.format(fnid)})
else:
supp_id = parse_attributes('(#fn{0})'.format(fnid))
if '^' not in self.atts:
sup = generate_tag('sup', fns.group('fnid'), supp_id)
else:
fnrev = generate_tag('a', fns.group('fnid'), {'href':
'#fnrev{0}'.format(fnid)})
sup = generate_tag('sup', fnrev, supp_id)
self.content = '{0} {1}'.format(sup, self.content)
if self.tag == 'bq':
if self.cite:
self.cite = self.textile.shelveURL(self.cite)
cite_att = OrderedDict(cite=self.cite)
self.cite = ' cite="{0}"'.format(self.cite)
else:
self.cite = ''
cite_att = OrderedDict()
cite_att.update(self.attributes)
self.outer_tag = 'blockquote'
self.outer_atts = cite_att
self.inner_tag = 'p'
self.inner_atts = self.attributes
self.eat = False
elif self.tag == 'bc' or self.tag == 'pre':
i_tag = ''
if self.tag == 'bc':
i_tag = 'code'
content = encode_html(self.content)
if not self.ext:
content = '{0}\n'.format(content)
self.content = self.textile.shelve(content)
self.outer_tag = 'pre'
self.outer_atts = self.attributes
self.inner_tag = i_tag
self.inner_atts = self.attributes
self.eat = False
elif self.tag == 'notextile':
self.content = self.textile.shelve(self.content)
elif self.tag == '###':
self.eat = True
else:
self.outer_tag = self.tag
self.outer_atts = self.attributes
if not self.eat:
self.content = self.textile.graf(self.content)
else:
self.content = ''
python-textile-2.3.5/textile/objects/table.py 0000664 0000000 0000000 00000020437 13004416251 0021270 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import six
from xml.etree import ElementTree
from textile.regex_strings import (align_re_s, cls_re_s, regex_snippets,
table_span_re_s, valign_re_s)
from textile.utils import encode_html, generate_tag, parse_attributes
try:
import regex as re
except ImportError:
import re
class Table(object):
def __init__(self, textile, tatts, rows, summary):
self.textile = textile
self.attributes = parse_attributes(tatts, 'table')
if summary:
self.attributes.update(summary=summary.strip())
self.input = rows
self.caption = ''
self.colgroup = ''
self.content = []
def process(self):
rgrp = None
groups = []
if self.input[-1] == '|': # pragma: no branch
self.input = '{0}\n'.format(self.input)
split = self.input.split('|\n')
for i, row in enumerate([x for x in split if x]):
row = row.lstrip()
# Caption -- only occurs on row 1, otherwise treat '|=. foo |...'
# as a normal center-aligned cell.
if i == 0 and row[:2] == '|=':
captionpattern = (r"^\|\=(?P<capts>{s}{a}{c})\. "
r"(?P<cap>[^\n]*)(?P<row>.*)".format(**{'s':
table_span_re_s, 'a': align_re_s, 'c': cls_re_s}))
caption_re = re.compile(captionpattern, re.S)
cmtch = caption_re.match(row)
caption = Caption(**cmtch.groupdict())
self.caption = '\n{0}'.format(caption.caption)
row = cmtch.group('row').lstrip()
if row == '':
continue
# Colgroup -- A colgroup row will not necessarily end with a |.
# Hence it may include the next row of actual table data.
if row[:2] == '|:':
if '\n' in row:
colgroup_data, row = row[2:].split('\n')
else:
colgroup_data, row = row[2:], ''
colgroup_atts, cols = colgroup_data, None
if '|' in colgroup_data:
colgroup_atts, cols = colgroup_data.split('|', 1)
colgrp = Colgroup(cols, colgroup_atts)
self.colgroup = colgrp.process()
if row == '':
continue
# search the row for a table group - thead, tfoot, or tbody
grpmatchpattern = (r"(:?^\|(?P<part>{v})(?P<rgrpatts>{s}{a}{c})"
r"\.\s*$\n)?^(?P<row>.*)").format(**{'v': valign_re_s, 's':
table_span_re_s, 'a': align_re_s, 'c': cls_re_s})
grpmatch_re = re.compile(grpmatchpattern, re.S | re.M)
grpmatch = grpmatch_re.match(row.lstrip())
grptypes = {'^': Thead, '~': Tfoot, '-': Tbody}
if grpmatch.group('part'):
# we're about to start a new group, so process the current one
# and add it to the output
if rgrp:
groups.append('\n\t{0}'.format(rgrp.process()))
rgrp = grptypes[grpmatch.group('part')](grpmatch.group(
'rgrpatts'))
row = grpmatch.group('row')
rmtch = re.search(r'^(?P<ratts>{0}{1}\. )(?P<row>.*)'.format(
align_re_s, cls_re_s), row.lstrip())
if rmtch:
row_atts = parse_attributes(rmtch.group('ratts'), 'tr')
row = rmtch.group('row')
else:
row_atts = {}
# create a row to hold the cells.
r = Row(row_atts, row)
for cellctr, cell in enumerate(row.split('|')[1:]):
ctag = 'td'
if cell.startswith('_'):
ctag = 'th'
cmtch = re.search(r'^(?P<catts>_?{0}{1}{2}\. )'
'(?P<cell>.*)'.format(table_span_re_s, align_re_s,
cls_re_s), cell, flags=re.S)
if cmtch:
catts = cmtch.group('catts')
cell_atts = parse_attributes(catts, 'td')
cell = cmtch.group('cell')
else:
cell_atts = {}
if not self.textile.lite:
a_pattern = r'(?P<space>{0}*)(?P<cell>.*)'.format(
regex_snippets['space'])
a = re.search(a_pattern, cell, flags=re.S)
cell = self.textile.redcloth_list(a.group('cell'))
cell = self.textile.textileLists(cell)
cell = '{0}{1}'.format(a.group('space'), cell)
# create a cell
c = Cell(ctag, cell, cell_atts)
cline_tag = '\n\t\t\t{0}'.format(c.process())
# add the cell to the row
r.cells.append(self.textile.doTagBr(ctag, cline_tag))
# if we're in a group, add it to the group's rows, else add it
# directly to the content
if rgrp:
rgrp.rows.append(r.process())
else:
self.content.append(r.process())
# if there's still an rgrp, process it and add it to the output
if rgrp:
groups.append('\n\t{0}'.format(rgrp.process()))
content = '{0}{1}{2}{3}\n\t'.format(self.caption, self.colgroup,
''.join(groups), ''.join(self.content))
tbl = generate_tag('table', content, self.attributes)
return '\t{0}\n\n'.format(tbl)
class Caption(object):
def __init__(self, capts, cap, row):
self.attributes = parse_attributes(capts)
self.caption = self.process(cap)
def process(self, cap):
tag = generate_tag('caption', cap, self.attributes)
return '\t{0}\n\t'.format(tag)
class Colgroup(object):
def __init__(self, cols, atts):
self.row = ''
self.attributes = atts
self.cols = cols
def process(self):
enc = 'unicode'
if six.PY2: # pragma: no branch
enc = 'UTF-8'
group_atts = parse_attributes(self.attributes, 'col')
colgroup = ElementTree.Element('colgroup', attrib=group_atts)
colgroup.text = '\n\t'
if self.cols is not None:
has_newline = "\n" in self.cols
match_cols = self.cols.replace('.', '').split('|')
# colgroup is the first item in match_cols, the remaining items are
# cols.
for idx, col in enumerate(match_cols):
col_atts = parse_attributes(col.strip(), 'col')
ElementTree.SubElement(colgroup, 'col', col_atts)
colgrp = ElementTree.tostring(colgroup, encoding=enc)
# cleanup the extra xml declaration if it exists, (python versions
# differ) and then format the resulting string accordingly: newline and
# tab between cols and a newline at the end
xml_declaration = "<?xml version='1.0' encoding='UTF-8'?>\n"
colgrp = colgrp.replace(xml_declaration, '')
return colgrp.replace('><', '>\n\t<')
class Row(object):
def __init__(self, attributes, row):
self.tag = 'tr'
self.attributes = attributes
self.cells = []
def process(self):
output = []
for c in self.cells:
output.append(c)
cell_data = '{0}\n\t\t'.format(''.join(output))
tag = generate_tag('tr', cell_data, self.attributes)
return '\n\t\t{0}'.format(tag)
class Cell(object):
def __init__(self, tag, content, attributes):
self.tag = tag
self.content = content
self.attributes = attributes
def process(self):
return generate_tag(self.tag, self.content, self.attributes)
class _TableSection(object):
def __init__(self, tag, attributes):
self.tag = tag
self.attributes = parse_attributes(attributes)
self.rows = []
def process(self):
return generate_tag(self.tag, '{0}\n\t'.format(''.join(self.rows)), self.attributes)
class Thead(_TableSection):
def __init__(self, attributes):
super(Thead, self).__init__('thead', attributes)
class Tbody(_TableSection):
def __init__(self, attributes):
super(Tbody, self).__init__('tbody', attributes)
class Tfoot(_TableSection):
def __init__(self, attributes):
super(Tfoot, self).__init__('tfoot', attributes)
python-textile-2.3.5/textile/regex_strings.py 0000664 0000000 0000000 00000003566 13004416251 0021437 0 ustar 00root root 0000000 0000000 # -*- coding: utf-8 -*-
from __future__ import unicode_literals
import six
try:
# Use regex module for matching uppercase characters if installed,
# otherwise fall back to finding all the uppercase chars in a loop.
import regex as re
upper_re_s = r'\p{Lu}'
regex_snippets = {
'acr': r'\p{Lu}\p{Nd}',
'abr': r'\p{Lu}',
'nab': r'\p{Ll}',
'wrd': r'(?:\p{L}|\p{M}|\p{N}|\p{Pc})',
'cur': r'\p{Sc}',
'digit': r'\p{N}',
'space': r'(?:\p{Zs}|\v)',
'char': r'(?:[^\p{Zs}\v])',
}
except ImportError:
import re
from sys import maxunicode
upper_re_s = "".join(
[six.unichr(c) for c in six.moves.range(maxunicode) if six.unichr(
c).isupper()])
regex_snippets = {
'acr': r'{0}0-9'.format(upper_re_s),
'abr': r'{0}'.format(upper_re_s),
'nab': r'a-z',
'wrd': r'\w',
'cur': r'',
'digit': r'\d',
'space': r'(?:\s|\v)',
'char': r'\S',
}
halign_re_s = r'(?:\<(?!>)|(?<!<)\>|\<\>|\=|[()]+(?! ))'
valign_re_s = r'[\-^~]'
class_re_s = r'(?:\([^)\n]+\))' # Don't allow classes/ids,
language_re_s = r'(?:\[[^\]\n]+\])' # languages,
style_re_s = r'(?:\{[^}\n]+\})' # or styles to span across newlines
colspan_re_s = r'(?:\\\d+)'
rowspan_re_s = r'(?:\/\d+)'
align_re_s = r'(?:{0}|{1})*'.format(halign_re_s, valign_re_s)
table_span_re_s = r'(?:{0}|{1})*'.format(colspan_re_s, rowspan_re_s)
# regex string to match class, style and language attributes
cls_re_s = (r'(?:'
r'{c}(?:{l}(?:{s})?|{s}(?:{l})?)?|'
r'{l}(?:{c}(?:{s})?|{s}(?:{c})?)?|'
r'{s}(?:{c}(?:{l})?|{l}(?:{c})?)?'
r')?'
).format(c=class_re_s, s=style_re_s, l=language_re_s)
pnct_re_s = r'[-!"#$%&()*+,/:;<=>?@\'\[\\\]\.^_`{|}~]'
syms_re_s = '¤§µ¶†‡•∗∴◊♠♣♥♦'
python-textile-2.3.5/textile/textilefactory.py 0000664 0000000 0000000 00000002410 13004416251 0021605 0 ustar 00root root 0000000 0000000 from __future__ import unicode_literals
from .core import Textile
class TextileFactory(object):
""" Use TextileFactory to create a Textile object which can be re-used to
process multiple strings with the same settings."""
def __init__(self, restricted=False, lite=False, sanitize=False,
noimage=None, get_sizes=False, html_type='xhtml'):
self.class_parms = {}
self.method_parms = {}
if lite and not restricted:
raise ValueError("lite can only be enabled in restricted mode")
if restricted:
self.class_parms['restricted'] = True
self.class_parms['lite'] = lite
self.method_parms['rel'] = 'nofollow'
if noimage is None:
if restricted:
noimage = True
else:
noimage = False
self.class_parms['noimage'] = noimage
self.method_parms['sanitize'] = sanitize
self.class_parms['get_sizes'] = get_sizes
if html_type not in ['xhtml', 'html5']:
raise ValueError("html_type must be 'xhtml' or 'html5'")
else:
self.class_parms['html_type'] = html_type
def process(self, text):
return Textile(**self.class_parms).parse(text, **self.method_parms)
python-textile-2.3.5/textile/tools/ 0000775 0000000 0000000 00000000000 13004416251 0017330 5 ustar 00root root 0000000 0000000 python-textile-2.3.5/textile/tools/__init__.py 0000664 0000000 0000000 00000000000 13004416251 0021427 0 ustar 00root root 0000000 0000000 python-textile-2.3.5/textile/tools/imagesize.py 0000664 0000000 0000000 00000001314 13004416251 0021656 0 ustar 00root root 0000000 0000000 def getimagesize(url):
"""
Attempts to determine an image's width and height, and returns a tuple,
(width, height), in pixels or an empty string in case of failure.
Requires that PIL is installed.
"""
try:
from PIL import ImageFile
except ImportError:
return ''
try:
from urllib.request import urlopen
except (ImportError):
from urllib2 import urlopen
try:
p = ImageFile.Parser()
f = urlopen(url)
while True:
s = f.read(1024)
if not s:
break
p.feed(s)
if p.image:
return p.image.size
except (IOError, ValueError):
return ''
python-textile-2.3.5/textile/tools/sanitizer.py 0000664 0000000 0000000 00000001155 13004416251 0021714 0 ustar 00root root 0000000 0000000 def sanitize(string):
"""
Ensure that the text does not contain any malicious HTML code which might
break the page.
"""
try:
import html5lib
from html5lib import sanitizer, serializer, treewalkers
except ImportError:
raise Exception("html5lib not available")
p = html5lib.HTMLParser(tokenizer=sanitizer.HTMLSanitizer)
tree = p.parseFragment(string)
walker = treewalkers.getTreeWalker("etree")
stream = walker(tree)
s = serializer.htmlserializer.HTMLSerializer(omit_optional_tags=False,
quote_attr_values=True)
return s.render(stream)
python-textile-2.3.5/textile/utils.py 0000664 0000000 0000000 00000015111 13004416251 0017701 0 ustar 00root root 0000000 0000000 from __future__ import unicode_literals
import six
try:
import regex as re
except ImportError:
import re
from six.moves import urllib, html_parser
urlparse = urllib.parse.urlparse
HTMLParser = html_parser.HTMLParser
try:
from collections import OrderedDict
except ImportError:
from ordereddict import OrderedDict
from xml.etree import ElementTree
from textile.regex_strings import valign_re_s, halign_re_s
def decode_high(text):
"""Decode encoded HTML entities."""
h = HTMLParser()
text = '&#{0};'.format(text)
return h.unescape(text)
def encode_high(text):
"""Encode the text so that it is an appropriate HTML entity."""
return ord(text)
def encode_html(text, quotes=True):
"""Return text that's safe for an HTML attribute."""
a = (
('&', '&'),
('<', '<'),
('>', '>'))
if quotes:
a = a + (("'", '''),
('"', '"'))
for k, v in a:
text = text.replace(k, v)
return text
def generate_tag(tag, content, attributes=None):
"""Generate a complete html tag using the ElementTree module. tag and
content are strings, the attributes argument is a dictionary. As
a convenience, if the content is ' /', a self-closing tag is generated."""
content = six.text_type(content)
enc = 'unicode'
if six.PY2:
enc = 'UTF-8'
if not tag:
return content
element = ElementTree.Element(tag, attrib=attributes)
# FIXME: Kind of an ugly hack. There *must* be a cleaner way. I tried
# adding text by assigning it to element_tag.text. That results in
# non-ascii text being html-entity encoded. Not bad, but not entirely
# matching php-textile either.
try:
element_tag = ElementTree.tostringlist(element, encoding=enc,
method='html')
element_tag.insert(len(element_tag) - 1, content)
element_text = ''.join(element_tag)
except AttributeError:
# Python 2.6 doesn't have the tostringlist method, so we have to treat
# it differently.
element_tag = ElementTree.tostring(element, encoding=enc)
element_text = re.sub(r"<\?xml version='1.0' encoding='UTF-8'\?>\n",
'', element_tag)
if content != six.text_type(' /'):
element_text = element_text.rstrip(' />')
element_text = six.text_type('{0}>{1}</{2}>').format(six.text_type(
element_text), content, tag)
return element_text
def has_raw_text(text):
"""checks whether the text has text not already enclosed by a block tag"""
# The php version has orders the below list of tags differently. The
# important thing to note here is that the pre must occur before the p or
# else the regex module doesn't properly match pre-s. It only matches the
# p in pre.
r = re.compile(r'<(pre|p|blockquote|div|form|table|ul|ol|dl|h[1-6])[^>]*?>.*</\1>',
re.S).sub('', text.strip()).strip()
r = re.compile(r'<(hr|br)[^>]*?/>').sub('', r)
return '' != r
def is_rel_url(url):
"""Identify relative urls."""
(scheme, netloc) = urlparse(url)[0:2]
return not scheme and not netloc
def is_valid_url(url):
parsed = urlparse(url)
if parsed.scheme == '':
return True
return False
def list_type(list_string):
listtypes = {
list_string.startswith('*'): 'u',
list_string.startswith('#'): 'o',
(not list_string.startswith('*') and not list_string.startswith('#')):
'd'
}
return listtypes.get(True, False)
def normalize_newlines(string):
out = string.strip()
out = re.sub(r'\r\n', '\n', out)
out = re.sub(r'\n{3,}', '\n\n', out)
out = re.sub(r'\n\s*\n', '\n\n', out)
out = re.sub(r'"$', '" ', out)
return out
def parse_attributes(block_attributes, element=None, include_id=True):
vAlign = {'^': 'top', '-': 'middle', '~': 'bottom'}
hAlign = {'<': 'left', '=': 'center', '>': 'right', '<>': 'justify'}
style = []
aclass = ''
lang = ''
colspan = ''
rowspan = ''
block_id = ''
span = ''
width = ''
result = OrderedDict()
if not block_attributes:
return result
matched = block_attributes
if element == 'td':
m = re.search(r'\\(\d+)', matched)
if m:
colspan = m.group(1)
m = re.search(r'/(\d+)', matched)
if m:
rowspan = m.group(1)
if element == 'td' or element == 'tr':
m = re.search(r'(^{0})'.format(valign_re_s), matched)
if m:
style.append("vertical-align:{0}".format(vAlign[m.group(1)]))
m = re.search(r'\{([^}]*)\}', matched)
if m:
style.extend(m.group(1).rstrip(';').split(';'))
matched = matched.replace(m.group(0), '')
m = re.search(r'\[([^\]]+)\]', matched, re.U)
if m:
lang = m.group(1)
matched = matched.replace(m.group(0), '')
m = re.search(r'\(([^()]+)\)', matched, re.U)
if m:
aclass = m.group(1)
matched = matched.replace(m.group(0), '')
m = re.search(r'([(]+)', matched)
if m:
style.append("padding-left:{0}em".format(len(m.group(1))))
matched = matched.replace(m.group(0), '')
m = re.search(r'([)]+)', matched)
if m:
style.append("padding-right:{0}em".format(len(m.group(1))))
matched = matched.replace(m.group(0), '')
m = re.search(r'({0})'.format(halign_re_s), matched)
if m:
style.append("text-align:{0}".format(hAlign[m.group(1)]))
m = re.search(r'^(.*)#(.*)$', aclass)
if m:
block_id = m.group(2)
aclass = m.group(1)
if element == 'col':
pattern = r'(?:\\(\d+)\.?)?\s*(\d+)?'
csp = re.match(pattern, matched)
span, width = csp.groups()
if colspan:
result['colspan'] = colspan
if style:
# Previous splits that created style may have introduced extra
# whitespace into the list elements. Clean it up.
style = [x.strip() for x in style]
result['style'] = '{0};'.format("; ".join(style))
if aclass:
result['class'] = aclass
if block_id and include_id:
result['id'] = block_id
if lang:
result['lang'] = lang
if rowspan:
result['rowspan'] = rowspan
if span:
result['span'] = span
if width:
result['width'] = width
return result
def pba(block_attributes, element=None, include_id=True):
"""Parse block attributes."""
attrs = parse_attributes(block_attributes, element, include_id)
if not attrs:
return ''
result = ' '.join(['{0}="{1}"'.format(k, v) for k, v in attrs.items()])
return ' {0}'.format(result)
python-textile-2.3.5/textile/version.py 0000664 0000000 0000000 00000000022 13004416251 0020221 0 ustar 00root root 0000000 0000000 VERSION = '2.3.5'