Markdown-3.1.1/tests/misc/escaped_chars_in_js.html 0000644 0000765 0000024 00000000723 13457143376 022664 0 ustar waylan staff 0000000 0000000 [javascript protected email address]
Markdown-3.1.1/tests/misc/escaped_chars_in_js.txt 0000644 0000765 0000024 00000000715 13457143376 022540 0 ustar waylan staff 0000000 0000000 [javascript protected email address]
Markdown-3.1.1/tests/misc/escaped_links.html 0000644 0000765 0000024 00000000324 13212354257 021506 0 ustar waylan staff 0000000 0000000 Backslashed in links:
q=go:GO\:0000307
q=go:GO\:0000308
a \non-escaped char.
Markdown-3.1.1/tests/misc/escaped_links.txt 0000644 0000765 0000024 00000000256 13212354257 021365 0 ustar waylan staff 0000000 0000000 Backslashed in links:
[q=go:GO\\:0000307](/query?q=go:GO\\:0000307)
[q=go:GO\\:0000308][foo]
[foo]: /query?q=go:GO\:0000308 "/query?q=go:GO\:0000308"
a \non-escaped char. Markdown-3.1.1/tests/misc/funky-list.html 0000644 0000765 0000024 00000000422 13212354257 021006 0 ustar waylan staff 0000000 0000000
- this starts a list with numbers
- this will show as number "2"
- this will show as number "3."
- any number, +, -, or * will keep the list going.
aaaaaaaaaaaaaaa
- now a normal list
- and more
Markdown-3.1.1/tests/misc/funky-list.txt 0000644 0000765 0000024 00000000313 13212354257 020660 0 ustar waylan staff 0000000 0000000 1. this starts a list *with* numbers
+ this will show as number "2"
* this will show as number "3."
9. any number, +, -, or * will keep the list going.
aaaaaaaaaaaaaaa
- now a normal list
- and more
Markdown-3.1.1/tests/misc/h1.html 0000644 0000765 0000024 00000000105 13212354257 017207 0 ustar waylan staff 0000000 0000000 Header
Header 2
H3
H1
H2
Markdown-3.1.1/tests/misc/h1.txt 0000644 0000765 0000024 00000000067 13212354257 017071 0 ustar waylan staff 0000000 0000000 Header
------
Header 2
========
### H3
H1
=
H2
--
Markdown-3.1.1/tests/misc/hash.html 0000644 0000765 0000024 00000000143 13212354257 017624 0 ustar waylan staff 0000000 0000000 a
#!/usr/bin/python
hello
a
!/usr/bin/python
hello
a
Markdown-3.1.1/tests/misc/hash.txt 0000644 0000765 0000024 00000000121 13212354257 017473 0 ustar waylan staff 0000000 0000000 a
#!/usr/bin/python
hello
a
!/usr/bin/python
hello
a
Markdown-3.1.1/tests/misc/header-in-lists.html 0000644 0000765 0000024 00000000524 13212354257 021674 0 ustar waylan staff 0000000 0000000 Tight List:
-
Header1
Line 1-2 - not a header or paragraph!
-
Header2
Line 2-2 - not a header or paragraph!
Loose List:
-
Header1
Line 1-2 - a paragraph
-
Header2
Line 2-2 - a paragraph
Markdown-3.1.1/tests/misc/header-in-lists.txt 0000644 0000765 0000024 00000000312 13212354257 021542 0 ustar waylan staff 0000000 0000000 Tight List:
* #Header1
Line 1-2 - **not** a header *or* paragraph!
* #Header2
Line 2-2 - not a header or paragraph!
Loose List:
* #Header1
Line 1-2 - *a* paragraph
* #Header2
Line 2-2 - a paragraph
Markdown-3.1.1/tests/misc/headers.html 0000644 0000765 0000024 00000000343 13212354257 020316 0 ustar waylan staff 0000000 0000000 Hello world
Line 2
Line 3
[Markdown][5]
[5]: http://foo.com/
Issue #1: Markdown
Text
Header
Some other text
Markdown-3.1.1/tests/misc/headers.txt 0000644 0000765 0000024 00000000243 13212354257 020170 0 ustar waylan staff 0000000 0000000 ### Hello world
Line 2
Line 3
# [Markdown][5]
# [Markdown](http://some.link.com/)
# [5]: http://foo.com/
# Issue #1: Markdown
Text
# Header
Some other text
Markdown-3.1.1/tests/misc/hline.html 0000644 0000765 0000024 00000000040 13212354257 017774 0 ustar waylan staff 0000000 0000000 Header
Next line
Markdown-3.1.1/tests/misc/hline.txt 0000644 0000765 0000024 00000000025 13212354257 017652 0 ustar waylan staff 0000000 0000000
#Header
Next line
Markdown-3.1.1/tests/misc/html-comments.html 0000644 0000765 0000024 00000000114 13457143376 021477 0 ustar waylan staff 0000000 0000000 Here is HTML
and once more
Markdown-3.1.1/tests/misc/html-comments.txt 0000644 0000765 0000024 00000000106 13457143376 021353 0 ustar waylan staff 0000000 0000000 Here is HTML
and once more
Markdown-3.1.1/tests/misc/html.html 0000644 0000765 0000024 00000001457 13457143376 017667 0 ustar waylan staff 0000000 0000000 Block level html
Some inline stuff.
Now some arbitrary tags.
More block level html.
Html with various attributes.
Div with a blank line
in the middle.
This gets treated as HTML.
And of course .
this .
[this )
Some funky inline stuff with markdown escaping syntax.
![]( "Only one inline element on a line.")
And now a line with only an opening bracket:
<
And one with other stuff but no closing bracket:
< foo
Markdown-3.1.1/tests/misc/image-2.html 0000644 0000765 0000024 00000000160 13212354257 020121 0 ustar waylan staff 0000000 0000000 link!
link
Markdown-3.1.1/tests/misc/image-2.txt 0000644 0000765 0000024 00000000100 13212354257 017766 0 ustar waylan staff 0000000 0000000 [*link!*](http://src.com/)
*[link](http://www.freewisdom.org)*
Markdown-3.1.1/tests/misc/image_in_links.html 0000644 0000765 0000024 00000000130 13212354257 021645 0 ustar waylan staff 0000000 0000000 
Markdown-3.1.1/tests/misc/image_in_links.txt 0000644 0000765 0000024 00000000071 13212354257 021524 0 ustar waylan staff 0000000 0000000
[](path/to/image.png)
Markdown-3.1.1/tests/misc/ins-at-start-of-paragraph.html 0000644 0000765 0000024 00000000114 13212354257 023572 0 ustar waylan staff 0000000 0000000 Hello, fellow developer this ins should be wrapped in a p.
Markdown-3.1.1/tests/misc/ins-at-start-of-paragraph.txt 0000644 0000765 0000024 00000000106 13212354257 023446 0 ustar waylan staff 0000000 0000000 Hello, fellow developer this ins should be wrapped in a p.
Markdown-3.1.1/tests/misc/inside_html.html 0000644 0000765 0000024 00000000061 13212354257 021177 0 ustar waylan staff 0000000 0000000 ok?
Markdown-3.1.1/tests/misc/inside_html.txt 0000644 0000765 0000024 00000000036 13212354257 021054 0 ustar waylan staff 0000000 0000000 __ok__?
Markdown-3.1.1/tests/misc/japanese.html 0000644 0000765 0000024 00000005657 13212354257 020506 0 ustar waylan staff 0000000 0000000 パイソン (Python)
Python（パイソン）は、Guido van Rossum によって作られたオープンソースのオブジェクト指向スクリプト言語。Perlとともに欧米で広く普及している。イギリスのテレビ局 BBC が製作したコメディ番組『空飛ぶモンティ・パイソン』にちなんで名付けられた。 (Pythonには、爬虫類のニシキヘビの意味があり、Python言語のマスコットやアイコンとして使われることがある。)
概要
プログラミング言語 Python は初心者から専門家まで幅広いユーザ層を獲得している。利用目的は汎用で、方向性としてはJavaに近い。ただし、最初からネットワーク利用をメインとして考えられているJavaよりセキュリティについてはやや寛大である。多くのプラットフォームをサポートしており（⇒動作するプラットフォーム)、豊富なライブラリがあることから、産業界でも利用が増えつつある。また、Pythonは純粋なプログラミング言語のほかにも、多くの異なる言語で書かれたモジュールをまとめる糊言語のひとつとして位置づけることができる。実際Pythonは多くの商用アプリケーションでスクリプト言語として採用されている（⇒Pythonを使っている製品あるいはソフトウェアの一覧）。豊富なドキュメントをもち、Unicodeによる文字列操作をサポートしており、日本語処理も標準で可能である。
Python は基本的にインタプリタ上で実行されることを念頭において設計されており、以下のような特徴をもっている:
- 動的な型付け。
- オブジェクトのメンバに対するアクセスが制限されていない。（属性や専用のメソッドフックを実装することによって制限は可能。）
- モジュール、クラス、オブジェクト等の言語の要素が内部からアクセス可能であり、リフレクションを利用した記述が可能。
また、Pythonではインデントによりブロックを指定する構文を採用している（⇒オフサイドルール）。この構文はPythonに慣れたユーザからは称賛をもって受け入れられているが、他の言語のユーザからは批判も多い。このほかにも、大きすぎる実行ファイルや、Javaに比べて遅い処理速度などが欠点として指摘されている。しかし プロトタイピング の際にはこれらの点はさして問題とはならないことから、研究開発部門では頻繁に利用されている。
Markdown-3.1.1/tests/misc/japanese.txt 0000644 0000765 0000024 00000005454 13212354257 020354 0 ustar waylan staff 0000000 0000000 パイソン (Python)
=======
**Python**（パイソン）は、[Guido van Rossum](http://en.wikipedia.org/wiki/Guido_van_Rossum) によって作られたオープンソースのオブジェクト指向スクリプト言語。[Perl](http://ja.wikipedia.org/wiki/Perl)とともに欧米で広く普及している。イギリスのテレビ局 BBC が製作したコメディ番組『空飛ぶモンティ・パイソン』にちなんで名付けられた。 (Pythonには、爬虫類のニシキヘビの意味があり、Python言語のマスコットやアイコンとして使われることがある。)
## 概要
プログラミング言語 Python は初心者から専門家まで幅広いユーザ層を獲得している。利用目的は汎用で、方向性としてはJavaに近い。ただし、最初からネットワーク利用をメインとして考えられているJavaよりセキュリティについてはやや寛大である。多くのプラットフォームをサポートしており（⇒[動作するプラットフォーム](#somelink))、豊富なライブラリがあることから、産業界でも利用が増えつつある。また、Pythonは純粋なプログラミング言語のほかにも、多くの異なる言語で書かれたモジュールをまとめる糊言語のひとつとして位置づけることができる。実際Pythonは多くの商用アプリケーションでスクリプト言語として採用されている（⇒Pythonを使っている製品あるいはソフトウェアの一覧）。豊富なドキュメントをもち、Unicodeによる文字列操作をサポートしており、日本語処理も標準で可能である。
Python は基本的にインタプリタ上で実行されることを念頭において設計されており、以下のような特徴をもっている:
* 動的な型付け。
* オブジェクトのメンバに対するアクセスが制限されていない。（属性や専用のメソッドフックを実装することによって制限は可能。）
* モジュール、クラス、オブジェクト等の言語の要素が内部からアクセス可能であり、リフレクションを利用した記述が可能。
また、Pythonではインデントによりブロックを指定する構文を採用している（⇒[オフサイドルール](#jklj)）。この構文はPythonに慣れたユーザからは称賛をもって受け入れられているが、他の言語のユーザからは批判も多い。このほかにも、大きすぎる実行ファイルや、Javaに比べて遅い処理速度などが欠点として指摘されている。しかし **プロトタイピング** の際にはこれらの点はさして問題とはならないことから、研究開発部門では頻繁に利用されている。
Markdown-3.1.1/tests/misc/lazy-block-quote.html 0000644 0000765 0000024 00000000232 13212354257 022102 0 ustar waylan staff 0000000 0000000
Line one of lazy block quote.
Line two of lazy block quote.
Line one of paragraph two.
Line two of paragraph two.
Markdown-3.1.1/tests/misc/lazy-block-quote.txt 0000644 0000765 0000024 00000000167 13212354257 021764 0 ustar waylan staff 0000000 0000000 > Line one of lazy block quote.
Line two of lazy block quote.
> Line one of paragraph two.
Line two of paragraph two.
Markdown-3.1.1/tests/misc/link-with-parenthesis.html 0000644 0000765 0000024 00000000215 13212354257 023132 0 ustar waylan staff 0000000 0000000 ZIP archives
Markdown-3.1.1/tests/misc/link-with-parenthesis.txt 0000644 0000765 0000024 00000000166 13212354257 023012 0 ustar waylan staff 0000000 0000000 [ZIP archives](http://en.wikipedia.org/wiki/ZIP_(file_format) "ZIP (file format) - Wikipedia, the free encyclopedia")
Markdown-3.1.1/tests/misc/lists.html 0000644 0000765 0000024 00000000646 13212354257 020047 0 ustar waylan staff 0000000 0000000
- A multi-paragraph list,
unindented.
Simple tight list
A singleton tight list:
A lose list:
A lose list with paragraphs
-
One one one one
one one one one
-
Two two two two
Markdown-3.1.1/tests/misc/lists.txt 0000644 0000765 0000024 00000000355 13212354257 017717 0 ustar waylan staff 0000000 0000000
* A multi-paragraph list,
unindented.
Simple tight list
* Uno
* Due
* Tri
A singleton tight list:
* Uno
A lose list:
* One
* Two
* Three
A lose list with paragraphs
* One one one one
one one one one
* Two two two two
Markdown-3.1.1/tests/misc/lists2.html 0000644 0000765 0000024 00000000114 13212354257 020117 0 ustar waylan staff 0000000 0000000
- blah blah blah
sdf asdf asdf asdf asdf
asda asdf asdfasd
Markdown-3.1.1/tests/misc/lists2.txt 0000644 0000765 0000024 00000000073 13212354257 017776 0 ustar waylan staff 0000000 0000000 * blah blah blah
sdf asdf asdf asdf asdf
asda asdf asdfasd
Markdown-3.1.1/tests/misc/lists3.html 0000644 0000765 0000024 00000000124 13212354257 020121 0 ustar waylan staff 0000000 0000000
- blah blah blah
sdf asdf asdf asdf asdf
asda asdf asdfasd
Markdown-3.1.1/tests/misc/lists3.txt 0000644 0000765 0000024 00000000103 13212354257 017771 0 ustar waylan staff 0000000 0000000 * blah blah blah
sdf asdf asdf asdf asdf
asda asdf asdfasd
Markdown-3.1.1/tests/misc/lists4.html 0000644 0000765 0000024 00000000127 13212354257 020125 0 ustar waylan staff 0000000 0000000
- item1
- item2
- Number 1
- Number 2
Markdown-3.1.1/tests/misc/lists4.txt 0000644 0000765 0000024 00000000061 13212354257 017775 0 ustar waylan staff 0000000 0000000
* item1
* item2
1. Number 1
2. Number 2
Markdown-3.1.1/tests/misc/lists5.html 0000644 0000765 0000024 00000000367 13212354257 020134 0 ustar waylan staff 0000000 0000000
This is a test of a block quote
With just two lines
A paragraph
This is a more difficult case
With a list item inside the quote
Markdown-3.1.1/tests/misc/lists5.txt 0000644 0000765 0000024 00000000247 13212354257 020004 0 ustar waylan staff 0000000 0000000 > This is a test of a block quote
> With just two lines
A paragraph
> This is a more difficult case
> With a list item inside the quote
>
> * Alpha
> * Beta
> Etc.
Markdown-3.1.1/tests/misc/lists6.html 0000644 0000765 0000024 00000000363 13212354257 020131 0 ustar waylan staff 0000000 0000000 Test five or more spaces as start of list:
not first item:
loose list:
Markdown-3.1.1/tests/misc/lists6.txt 0000644 0000765 0000024 00000000233 13212354257 020000 0 ustar waylan staff 0000000 0000000 Test five or more spaces as start of list:
* five spaces
not first item:
* one space
* five spaces
loose list:
* one space
* five spaces
Markdown-3.1.1/tests/misc/lists7.html 0000644 0000765 0000024 00000001746 13212354257 020140 0 ustar waylan staff 0000000 0000000
- item 1
-
- item 2-1
- item 2-2
- item 2-3
- item 2-4
- item 3
-
-
item 4-1
-
item 4-2
-
item 4-3
-
item 4-4
same as above, different spacing
only 1 item in nested list ##
Something ludicrous ##
- item 1
-
- item 2-1
- item 2-2
-
- item 2-3
- item 3
-
Markdown-3.1.1/tests/misc/lists7.txt 0000644 0000765 0000024 00000001025 13212354257 020001 0 ustar waylan staff 0000000 0000000 * item 1
* * item 2-1
* item 2-2
* item 2-3
* item 2-4
* item 3
* * item 4-1
* item 4-2
* item 4-3
* item 4-4
## same as above, different spacing
* item 1
* * item 2-1
* item 2-2
* item 3
* * item 4-1
* item 4-2
## only 1 item in nested list ##
* item 1
* * item 2-1
* item 3
* * item 4-1
## Something ludicrous ##
* item 1
* * item 2-1
* item 2-2
* * item 2-2-1
* item 2-2-2
* item 2-3
* item 3
* * item 4-1
* * item 4-1-1
* item 4-1-2
* item 4-2
Markdown-3.1.1/tests/misc/lists8.html 0000644 0000765 0000024 00000001062 13212354257 020130 0 ustar waylan staff 0000000 0000000 Lists with blockquotes
-
Four-score and seven years ago...
-
We have nothing to fear...
-
This is it...
Multi-line blockquotes
-
Four-score and sever years ago
our fathers brought forth
-
We have nothing to fear
but fear itself
-
This is it
as far as I'm concerned
Markdown-3.1.1/tests/misc/lists8.txt 0000644 0000765 0000024 00000000455 13212354257 020010 0 ustar waylan staff 0000000 0000000 # Lists with blockquotes
1. > Four-score and seven years ago...
2. > We have nothing to fear...
3. > This is it...
# Multi-line blockquotes
* > Four-score and sever years ago
> our fathers brought forth
* > We have nothing to fear
> but fear itself
* > This is it
> as far as I'm concerned
Markdown-3.1.1/tests/misc/markup-inside-p.html 0000644 0000765 0000024 00000000120 13457143376 021712 0 ustar waylan staff 0000000 0000000
_foo_
_foo_
_foo_
_foo_
_foo_
Markdown-3.1.1/tests/misc/markup-inside-p.txt 0000644 0000765 0000024 00000000121 13457143376 021566 0 ustar waylan staff 0000000 0000000
_foo_
_foo_
_foo_
_foo_
_foo_
Markdown-3.1.1/tests/misc/mismatched-tags.html 0000644 0000765 0000024 00000000377 13457143376 021775 0 ustar waylan staff 0000000 0000000 Some text
some more text
and a bit more
And this output
Compatible with PHP Markdown Extra 1.2.2 and Markdown.pl1.0.2b8:
text
Should be in p
Markdown-3.1.1/tests/misc/mismatched-tags.txt 0000644 0000765 0000024 00000000331 13457143376 021636 0 ustar waylan staff 0000000 0000000 Some text
some more text
and a bit more
And this output
*Compatible with PHP Markdown Extra 1.2.2 and Markdown.pl1.0.2b8:*
text
Should be in p
Markdown-3.1.1/tests/misc/missing-link-def.html 0000644 0000765 0000024 00000000151 13212354257 022040 0 ustar waylan staff 0000000 0000000 This is a [missing link][empty] and a valid and [missing][again].
Markdown-3.1.1/tests/misc/missing-link-def.txt 0000644 0000765 0000024 00000000147 13212354257 021720 0 ustar waylan staff 0000000 0000000 This is a [missing link][empty] and a [valid][link] and [missing][again].
[link]: http://example.com
Markdown-3.1.1/tests/misc/more_comments.html 0000644 0000765 0000024 00000000155 13457143376 021564 0 ustar waylan staff 0000000 0000000
Foo
Bar
foo
foo
foo
foo
This shouldn't
<?php echo "not_block_level";?>
Markdown-3.1.1/tests/misc/php.txt 0000644 0000765 0000024 00000000376 13457143376 017364 0 ustar waylan staff 0000000 0000000
This should have a p tag
This shouldn't
Markdown-3.1.1/tests/misc/pre.html 0000644 0000765 0000024 00000000221 13457143376 017475 0 ustar waylan staff 0000000 0000000
aaa
bbb
* and this is pre-formatted content
* and it should be printed just like this
* and not formatted as a list
Markdown-3.1.1/tests/misc/pre.txt 0000644 0000765 0000024 00000000223 13457143376 017352 0 ustar waylan staff 0000000 0000000
aaa
bbb
* and this is pre-formatted content
* and it should be printed just like this
* and not formatted as a list
Markdown-3.1.1/tests/misc/raw_whitespace.html 0000644 0000765 0000024 00000000173 13457143376 021722 0 ustar waylan staff 0000000 0000000 Preserve whitespace in raw html
class Foo():
bar = 'bar'
def baz(self):
print self.bar
Markdown-3.1.1/tests/misc/raw_whitespace.txt 0000644 0000765 0000024 00000000167 13457143376 021600 0 ustar waylan staff 0000000 0000000 Preserve whitespace in raw html
class Foo():
bar = 'bar'
def baz(self):
print self.bar
Markdown-3.1.1/tests/misc/russian.html 0000644 0000765 0000024 00000006433 13212354257 020375 0 ustar waylan staff 0000000 0000000 Недвард «Нед» Фландерс
Недвард «Нед» Фландерс (Nedward «Ned» Flanders) — вымышленный персонаж мультсериала «[Симпсоны][]», озвученный Гарри Ширером. Он и его семья живут по соседству от семьи Симпсонов. Набожный христианин, Нед является одним из столпов морали Спрингфилда. В эпизоде «Alone Again, Natura-Diddily» он овдовел, его жена Мод погибла в результате несчастного случая.
Нед был одним из первых персонажей в мультсериале, который не был членом семьи Симпсонов. Начиная с первых серий, он регулярно появляется в «Симпсонах». Считается, что Нед Фландерс был назван в честь улицы Northeast Flanders St. в Портленде, Орегон, родном городе создателя мультсериала Мэтта Грейнинга]]. Надпись на указателе улицы NE Flanders St. хулиганы часто исправляли на NED Flanders St.
Биография
Нед Фландерс родился в Нью-Йорке, его родители были битниками. Его отец в точности похож на взрослого Неда, только он носил козлиную бородку. Их отказ от воспитания Неда и то, что они, в общем-то, были плохими родителями («мы ничего в этом не понимаем и не знаем как начать») привело к тому, что Нед превратился в ужасного сорванца. В конце концов они согласились на экспериментальную восьмимесячную шлепологическую терапию Миннесотского Университета (воспоминания Неда в эпизоде «Hurricane Neddy»), которая научила его подавлять чувство злости. Побочным эфектом терапии стало то, что Нед стал ненавидеть своих родителей (это одна из двух вещей которые ненавидит Фландерс, вторая — отделения почты, чьи длинные очереди, суета и угрюмый персонал раздражают его).
У Неда есть странная привычка добавлять «дидли», «дадли» и другие бессмысленные слова в свои фразы при разговоре, например: «Hi-diddly-ho, neighbor-ino» («Приветик, соседушка»). Это результат сублимации его злости, вызванной сдерживанием гнева, который не имеет никакого другого выхода.
Markdown-3.1.1/tests/misc/russian.txt 0000644 0000765 0000024 00000006343 13212354257 020250 0 ustar waylan staff 0000000 0000000 Недвард «Нед» Фландерс
======================
**Недвард «Нед» Фландерс** (Nedward «Ned» Flanders) — вымышленный персонаж мультсериала «[Симпсоны][]», озвученный Гарри Ширером. Он и его семья живут по соседству от семьи Симпсонов. Набожный христианин, Нед является одним из столпов морали Спрингфилда. В эпизоде «Alone Again, Natura-Diddily» он овдовел, его жена Мод погибла в результате несчастного случая.
Нед был одним из первых персонажей в мультсериале, который не был членом семьи Симпсонов. Начиная с первых серий, он регулярно появляется в «Симпсонах». Считается, что Нед Фландерс был назван в честь улицы *Northeast Flanders St.* в [Портленде](http://www.portland.gov), Орегон, родном городе создателя мультсериала Мэтта Грейнинга]]. Надпись на указателе улицы *NE Flanders St.* хулиганы часто исправляли на _NED Flanders St._
## Биография
Нед Фландерс родился в Нью-Йорке, его родители были битниками. Его отец в точности похож на взрослого Неда, только он носил козлиную бородку. Их отказ от воспитания Неда и то, что они, в общем-то, были плохими родителями («мы ничего в этом не понимаем и не знаем как начать») привело к тому, что Нед превратился в ужасного сорванца. В конце концов они согласились на экспериментальную восьмимесячную шлепологическую терапию Миннесотского Университета (воспоминания Неда в эпизоде «Hurricane Neddy»), которая научила его подавлять чувство злости. Побочным эфектом терапии стало то, что Нед стал ненавидеть своих родителей (это одна из двух вещей которые ненавидит Фландерс, вторая — отделения почты, чьи длинные очереди, суета и угрюмый персонал раздражают его).
У Неда есть странная привычка добавлять «дидли», «дадли» и другие бессмысленные слова в свои фразы при разговоре, например: «Hi-diddly-ho, neighbor-ino» («Приветик, соседушка»). Это результат сублимации его злости, вызванной сдерживанием гнева, который не имеет никакого другого выхода.
Markdown-3.1.1/tests/misc/smart_em.html 0000644 0000765 0000024 00000000262 13212354257 020512 0 ustar waylan staff 0000000 0000000 emphasis
this_is_not_emphasis
[punctuation with emphasis]
[punctuation_with_emphasis]
[punctuation_without_emphasis]
Markdown-3.1.1/tests/misc/smart_em.txt 0000644 0000765 0000024 00000000177 13212354257 020372 0 ustar waylan staff 0000000 0000000 _emphasis_
this_is_not_emphasis
[_punctuation with emphasis_]
[_punctuation_with_emphasis_]
[punctuation_without_emphasis]
Markdown-3.1.1/tests/misc/some-test.html 0000644 0000765 0000024 00000001326 13212354257 020625 0 ustar waylan staff 0000000 0000000
Markdown
-
Python
is ok
-
Perl sucks
big time
-
Python is
ok
Or not?
Here is a normal paragraph
- Another list
with a bunch of items
-
Mostly fruits
- Apple
- Pare
asdfasdfasd
# This is a code example
import stuff
Another code example
* Lists and similar stuff
> Should be ignored
Markdown-3.1.1/tests/misc/some-test.txt 0000644 0000765 0000024 00000001031 13212354257 020471 0 ustar waylan staff 0000000 0000000 ----------------------
* as if
* as if2
----------------------
* as if
* as if2
----------------------
* as if
non_code
* as if2
Markdown
* Python
is ok
* Therefore i am
* Perl sucks
big time
* But that's
ok
* Python is
ok
Or not?
Here is a normal paragraph
1. Another list
with a bunch of items
2. Mostly fruits
3. Apple
4. Pare
asdfasdfasd
# This is a code example
import stuff
Another code example
* Lists and similar stuff
> Should be ignored
Markdown-3.1.1/tests/misc/span.html 0000644 0000765 0000024 00000000256 13212354257 017647 0 ustar waylan staff 0000000 0000000 Foo bar Baz
*foo*
Foo *bar* Baz
Foo bar Baz
Markdown-3.1.1/tests/misc/span.txt 0000644 0000765 0000024 00000000227 13212354257 017520 0 ustar waylan staff 0000000 0000000
Foo *bar* Baz
*foo*
Foo *bar* Baz
Foo *bar* Baz
Markdown-3.1.1/tests/misc/strong-with-underscores.html 0000644 0000765 0000024 00000000046 13212354257 023522 0 ustar waylan staff 0000000 0000000 this_is_strong
Markdown-3.1.1/tests/misc/strong-with-underscores.txt 0000644 0000765 0000024 00000000023 13212354257 023370 0 ustar waylan staff 0000000 0000000 __this_is_strong__
Markdown-3.1.1/tests/misc/stronintags.html 0000644 0000765 0000024 00000000346 13212354257 021261 0 ustar waylan staff 0000000 0000000 this is a test
this is a second test
reference [test][]
reference [test][]
Markdown-3.1.1/tests/misc/stronintags.txt 0000644 0000765 0000024 00000000214 13212354257 021126 0 ustar waylan staff 0000000 0000000 this is a [**test**](http://example.com/)
this is a second **[test](http://example.com)**
reference **[test][]**
reference [**test**][]
Markdown-3.1.1/tests/misc/tabs-in-lists.html 0000644 0000765 0000024 00000000662 13212354257 021400 0 ustar waylan staff 0000000 0000000 First a list with a tabbed line
Just a blank line:
Now a list with 4 spaces and some text:
Now with a tab and an extra space:
Now a list with 4 spaces:
Markdown-3.1.1/tests/misc/tabs-in-lists.txt 0000644 0000765 0000024 00000000342 13212354257 021246 0 ustar waylan staff 0000000 0000000 First a list with a tabbed line
* A
* B
Just a blank line:
* A
* B
Now a list with 4 spaces and some text:
* A
abcdef
* B
Now with a tab and an extra space:
* A
* B
Now a list with 4 spaces:
* A
* B
Markdown-3.1.1/tests/misc/two-spaces.html 0000644 0000765 0000024 00000000644 13212354257 020774 0 ustar waylan staff 0000000 0000000 This line has two spaces at the end
but this one has none
but this line has three
and this is the second from last line
in this test message
And this is the end.
Markdown-3.1.1/tests/misc/two-spaces.txt 0000644 0000765 0000024 00000000532 13212354257 020643 0 ustar waylan staff 0000000 0000000 This line has two spaces at the end
but this one has none
but this line has three
and this is the second from last line
in this test message
* This list item has two spaces.
* This has none.
This line has three.
This line has none.
And this line two.
This line has none.
* This line has none.
And this is the end.
Markdown-3.1.1/tests/misc/uche.html 0000644 0000765 0000024 00000000456 13330711640 017626 0 ustar waylan staff 0000000 0000000 
Markdown-3.1.1/tests/misc/uche.txt 0000644 0000765 0000024 00000000312 13330711640 017470 0 ustar waylan staff 0000000 0000000 
[](http://fourthought.com/)
[](http://link.com/)
Markdown-3.1.1/tests/misc/underscores.html 0000644 0000765 0000024 00000000365 13432642364 021246 0 ustar waylan staff 0000000 0000000 THIS_SHOULD_STAY_AS_IS
Here is some emphasis, ok?
Ok, at least this should work.
THIS__SHOULD__STAY
Here is some strong stuff.
THISSHOULDSTAY?
Markdown-3.1.1/tests/misc/underscores.txt 0000644 0000765 0000024 00000000242 13212354257 021110 0 ustar waylan staff 0000000 0000000 THIS_SHOULD_STAY_AS_IS
Here is some _emphasis_, ok?
Ok, at least _this_ should work.
THIS__SHOULD__STAY
Here is some __strong__ stuff.
THIS___SHOULD___STAY?
Markdown-3.1.1/tests/misc/url_spaces.html 0000644 0000765 0000024 00000000241 13212354257 021040 0 ustar waylan staff 0000000 0000000 Dawn of War
Dawn of War
Markdown-3.1.1/tests/misc/url_spaces.txt 0000644 0000765 0000024 00000000172 13212354257 020716 0 ustar waylan staff 0000000 0000000 [Dawn of War](http://wikipedia.org/wiki/Dawn of War)
[Dawn of War](http://wikipedia.org/wiki/Dawn of War "Dawn of War")
Markdown-3.1.1/tests/pl/ 0000755 0000765 0000024 00000000000 13470647776 015516 5 ustar waylan staff 0000000 0000000 Markdown-3.1.1/tests/pl/Tests_2004/ 0000755 0000765 0000024 00000000000 13470647777 017266 5 ustar waylan staff 0000000 0000000 Markdown-3.1.1/tests/pl/Tests_2004/Amps and angle encoding.html 0000644 0000765 0000024 00000000771 13212354257 024400 0 ustar waylan staff 0000000 0000000 AT&T has an ampersand in their name.
AT&T is another way to write it.
This & that.
4 < 5.
6 > 5.
Here's a link with an ampersand in the URL.
Here's a link with an amersand in the link text: AT&T.
Here's an inline link.
Here's an inline link.
Markdown-3.1.1/tests/pl/Tests_2004/Auto links.html 0000644 0000765 0000024 00000001042 13212354257 022140 0 ustar waylan staff 0000000 0000000 Link: http://example.com/.
With an ampersand: http://example.com/?foo=1&bar=2
Blockquoted: http://example.com/
Auto-links should not occur here: <http://example.com/>
or here: <http://example.com/>
Markdown-3.1.1/tests/pl/Tests_2004/Backslash escapes.html 0000644 0000765 0000024 00000002426 13212354257 023435 0 ustar waylan staff 0000000 0000000 These should all get escaped:
Backslash: \
Backtick: `
Asterisk: *
Underscore: _
Left brace: {
Right brace: }
Left bracket: [
Right bracket: ]
Left paren: (
Right paren: )
Greater-than: >
Hash: #
Period: .
Bang: !
Plus: +
Minus: -
These should not, because they occur within a code block:
Backslash: \\
Backtick: \`
Asterisk: \*
Underscore: \_
Left brace: \{
Right brace: \}
Left bracket: \[
Right bracket: \]
Left paren: \(
Right paren: \)
Greater-than: \>
Hash: \#
Period: \.
Bang: \!
Plus: \+
Minus: \-
Nor should these, which occur in code spans:
Backslash: \\
Backtick: \`
Asterisk: \*
Underscore: \_
Left brace: \{
Right brace: \}
Left bracket: \[
Right bracket: \]
Left paren: \(
Right paren: \)
Greater-than: \>
Hash: \#
Period: \.
Bang: \!
Plus: \+
Minus: \-
Markdown-3.1.1/tests/pl/Tests_2004/Blockquotes with code blocks.html 0000644 0000765 0000024 00000000272 13212354257 025513 0 ustar waylan staff 0000000 0000000
Example:
sub status {
print "working";
}
Or:
sub status {
return "working";
}
Markdown-3.1.1/tests/pl/Tests_2004/Hard-wrapped paragraphs with list-like lines.html 0000644 0000765 0000024 00000000323 13212354257 030464 0 ustar waylan staff 0000000 0000000 In Markdown 1.0.0 and earlier. Version
8. This line turns into a list item.
Because a hard-wrapped line in the
middle of a paragraph looked like a
list item.
Here's one with a bullet.
* criminey.
Markdown-3.1.1/tests/pl/Tests_2004/Horizontal rules.html 0000644 0000765 0000024 00000000661 13212354257 023401 0 ustar waylan staff 0000000 0000000 Dashes:
---
- - -
Asterisks:
***
* * *
Underscores:
___
_ _ _
Markdown-3.1.1/tests/pl/Tests_2004/Inline HTML (Advanced).html 0000644 0000765 0000024 00000000224 13212354257 023702 0 ustar waylan staff 0000000 0000000 Simple block on one line:
foo
And nested without indentation:
Markdown-3.1.1/tests/pl/Tests_2004/Inline HTML (Simple).html 0000644 0000765 0000024 00000001420 13212354257 023425 0 ustar waylan staff 0000000 0000000 Here's a simple block:
foo
This should be a code block, though:
<div>
foo
</div>
As should this:
<div>foo</div>
Now, nested:
This should just be an HTML comment:
Multiline:
Code block:
<!-- Comment -->
Just plain comment, with trailing spaces on the line:
Code:
<hr />
Hr's:
Markdown-3.1.1/tests/pl/Tests_2004/Inline HTML comments.html 0000644 0000765 0000024 00000000274 13212354257 023706 0 ustar waylan staff 0000000 0000000 Paragraph one.
Paragraph two.
The end.
Markdown-3.1.1/tests/pl/Tests_2004/Links, inline style.html 0000644 0000765 0000024 00000000431 13212354257 023644 0 ustar waylan staff 0000000 0000000 Just a URL.
URL and title.
URL and title.
URL and title.
Empty.
Markdown-3.1.1/tests/pl/Tests_2004/Links, reference style.html 0000644 0000765 0000024 00000000627 13212354257 024333 0 ustar waylan staff 0000000 0000000 Foo bar.
Foo bar.
Foo bar.
With embedded [brackets].
Indented once.
Indented twice.
Indented thrice.
Indented [four][] times.
[four]: /url
Markdown-3.1.1/tests/pl/Tests_2004/Literal quotes in titles.html 0000644 0000765 0000024 00000000243 13212354257 024702 0 ustar waylan staff 0000000 0000000 Foo bar.
Foo bar.
Markdown-3.1.1/tests/pl/Tests_2004/Markdown Documentation - Basics.html 0000644 0000765 0000024 00000022250 13212354257 026011 0 ustar waylan staff 0000000 0000000 Markdown: Basics
Getting the Gist of Markdown's Formatting Syntax
This page offers a brief overview of what it's like to use Markdown.
The syntax page provides complete, detailed documentation for
every feature, but Markdown should be very easy to pick up simply by
looking at a few examples of it in action. The examples on this page
are written in a before/after style, showing example syntax and the
HTML output produced by Markdown.
It's also helpful to simply try Markdown out; the Dingus is a
web application that allows you type your own Markdown-formatted text
and translate it to XHTML.
Note: This document is itself written using Markdown; you
can see the source for it by adding '.text' to the URL.
Paragraphs, Headers, Blockquotes
A paragraph is simply one or more consecutive lines of text, separated
by one or more blank lines. (A blank line is any line that looks like a
blank line -- a line containing nothing spaces or tabs is considered
blank.) Normal paragraphs should not be intended with spaces or tabs.
Markdown offers two styles of headers: Setext and atx.
Setext-style headers for <h1> and <h2> are created by
"underlining" with equal signs (=) and hyphens (-), respectively.
To create an atx-style header, you put 1-6 hash marks (#) at the
beginning of the line -- the number of hashes equals the resulting
HTML header level.
Blockquotes are indicated using email-style '>' angle brackets.
Markdown:
A First Level Header
====================
A Second Level Header
---------------------
Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.
The quick brown fox jumped over the lazy
dog's back.
### Header 3
> This is a blockquote.
>
> This is the second paragraph in the blockquote.
>
> ## This is an H2 in a blockquote
Output:
<h1>A First Level Header</h1>
<h2>A Second Level Header</h2>
<p>Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.</p>
<p>The quick brown fox jumped over the lazy
dog's back.</p>
<h3>Header 3</h3>
<blockquote>
<p>This is a blockquote.</p>
<p>This is the second paragraph in the blockquote.</p>
<h2>This is an H2 in a blockquote</h2>
</blockquote>
Phrase Emphasis
Markdown uses asterisks and underscores to indicate spans of emphasis.
Markdown:
Some of these words *are emphasized*.
Some of these words _are emphasized also_.
Use two asterisks for **strong emphasis**.
Or, if you prefer, __use two underscores instead__.
Output:
<p>Some of these words <em>are emphasized</em>.
Some of these words <em>are emphasized also</em>.</p>
<p>Use two asterisks for <strong>strong emphasis</strong>.
Or, if you prefer, <strong>use two underscores instead</strong>.</p>
Lists
Unordered (bulleted) lists use asterisks, pluses, and hyphens (*,
+, and -) as list markers. These three markers are
interchangable; this:
* Candy.
* Gum.
* Booze.
this:
+ Candy.
+ Gum.
+ Booze.
and this:
- Candy.
- Gum.
- Booze.
all produce the same output:
<ul>
<li>Candy.</li>
<li>Gum.</li>
<li>Booze.</li>
</ul>
Ordered (numbered) lists use regular numbers, followed by periods, as
list markers:
1. Red
2. Green
3. Blue
Output:
<ol>
<li>Red</li>
<li>Green</li>
<li>Blue</li>
</ol>
If you put blank lines between items, you'll get <p> tags for the
list item text. You can create multi-paragraph list items by indenting
the paragraphs by 4 spaces or 1 tab:
* A list item.
With multiple paragraphs.
* Another item in the list.
Output:
<ul>
<li><p>A list item.</p>
<p>With multiple paragraphs.</p></li>
<li><p>Another item in the list.</p></li>
</ul>
Links
Markdown supports two styles for creating links: inline and
reference. With both styles, you use square brackets to delimit the
text you want to turn into a link.
Inline-style links use parentheses immediately after the link text.
For example:
This is an [example link](http://example.com/).
Output:
<p>This is an <a href="http://example.com/">
example link</a>.</p>
Optionally, you may include a title attribute in the parentheses:
This is an [example link](http://example.com/ "With a Title").
Output:
<p>This is an <a href="http://example.com/" title="With a Title">
example link</a>.</p>
Reference-style links allow you to refer to your links by names, which
you define elsewhere in your document:
I get 10 times more traffic from [Google][1] than from
[Yahoo][2] or [MSN][3].
[1]: http://google.com/ "Google"
[2]: http://search.yahoo.com/ "Yahoo Search"
[3]: http://search.msn.com/ "MSN Search"
Output:
<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from <a href="http://search.yahoo.com/"
title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/"
title="MSN Search">MSN</a>.</p>
The title attribute is optional. Link names may contain letters,
numbers and spaces, but are not case sensitive:
I start my morning with a cup of coffee and
[The New York Times][NY Times].
[ny times]: http://www.nytimes.com/
Output:
<p>I start my morning with a cup of coffee and
<a href="http://www.nytimes.com/">The New York Times</a>.</p>
Images
Image syntax is very much like link syntax.
Inline (titles are optional):
Reference-style:
![alt text][id]
[id]: /path/to/img.jpg "Title"
Both of the above examples produce the same output:
<img src="/path/to/img.jpg" alt="alt text" title="Title" />
Code
In a regular paragraph, you can create code span by wrapping text in
backtick quotes. Any ampersands (&) and angle brackets (< or
>) will automatically be translated into HTML entities. This makes
it easy to use Markdown to write about HTML example code:
I strongly recommend against using any `<blink>` tags.
I wish SmartyPants used named entities like `—`
instead of decimal-encoded entites like `—`.
Output:
<p>I strongly recommend against using any
<code><blink></code> tags.</p>
<p>I wish SmartyPants used named entities like
<code>&mdash;</code> instead of decimal-encoded
entites like <code>&#8212;</code>.</p>
To specify an entire block of pre-formatted code, indent every line of
the block by 4 spaces or 1 tab. Just like with code spans, &, <,
and > characters will be escaped automatically.
Markdown:
If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:
<blockquote>
<p>For example.</p>
</blockquote>
Output:
<p>If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:</p>
<pre><code><blockquote>
<p>For example.</p>
</blockquote>
</code></pre>
Markdown-3.1.1/tests/pl/Tests_2004/Markdown Documentation - Syntax.html 0000644 0000765 0000024 00000076051 13212354257 026103 0 ustar waylan staff 0000000 0000000 Markdown: Syntax
Note: This document is itself written using Markdown; you
can see the source for it by adding '.text' to the URL.
Overview
Philosophy
Markdown is intended to be as easy-to-read and easy-to-write as is feasible.
Readability, however, is emphasized above all else. A Markdown-formatted
document should be publishable as-is, as plain text, without looking
like it's been marked up with tags or formatting instructions. While
Markdown's syntax has been influenced by several existing text-to-HTML
filters -- including Setext, atx, Textile, reStructuredText,
Grutatext, and EtText -- the single biggest source of
inspiration for Markdown's syntax is the format of plain text email.
To this end, Markdown's syntax is comprised entirely of punctuation
characters, which punctuation characters have been carefully chosen so
as to look like what they mean. E.g., asterisks around a word actually
look like *emphasis*. Markdown lists look like, well, lists. Even
blockquotes look like quoted passages of text, assuming you've ever
used email.
Inline HTML
Markdown's syntax is intended for one purpose: to be used as a
format for writing for the web.
Markdown is not a replacement for HTML, or even close to it. Its
syntax is very small, corresponding only to a very small subset of
HTML tags. The idea is not to create a syntax that makes it easier
to insert HTML tags. In my opinion, HTML tags are already easy to
insert. The idea for Markdown is to make it easy to read, write, and
edit prose. HTML is a publishing format; Markdown is a writing
format. Thus, Markdown's formatting syntax only addresses issues that
can be conveyed in plain text.
For any markup that is not covered by Markdown's syntax, you simply
use HTML itself. There's no need to preface it or delimit it to
indicate that you're switching from Markdown to HTML; you just use
the tags.
The only restrictions are that block-level HTML elements -- e.g. <div>,
<table>, <pre>, <p>, etc. -- must be separated from surrounding
content by blank lines, and the start and end tags of the block should
not be indented with tabs or spaces. Markdown is smart enough not
to add extra (unwanted) <p> tags around HTML block-level tags.
For example, to add an HTML table to a Markdown article:
This is a regular paragraph.
<table>
<tr>
<td>Foo</td>
</tr>
</table>
This is another regular paragraph.
Note that Markdown formatting syntax is not processed within block-level
HTML tags. E.g., you can't use Markdown-style *emphasis* inside an
HTML block.
Span-level HTML tags -- e.g. <span>, <cite>, or <del> -- can be
used anywhere in a Markdown paragraph, list item, or header. If you
want, you can even use HTML tags instead of Markdown formatting; e.g. if
you'd prefer to use HTML <a> or <img> tags instead of Markdown's
link or image syntax, go right ahead.
Unlike block-level HTML tags, Markdown syntax is processed within
span-level tags.
Automatic Escaping for Special Characters
In HTML, there are two characters that demand special treatment: <
and &. Left angle brackets are used to start tags; ampersands are
used to denote HTML entities. If you want to use them as literal
characters, you must escape them as entities, e.g. <, and
&.
Ampersands in particular are bedeviling for web writers. If you want to
write about 'AT&T', you need to write 'AT&T'. You even need to
escape ampersands within URLs. Thus, if you want to link to:
http://images.google.com/images?num=30&q=larry+bird
you need to encode the URL as:
http://images.google.com/images?num=30&q=larry+bird
in your anchor tag href attribute. Needless to say, this is easy to
forget, and is probably the single most common source of HTML validation
errors in otherwise well-marked-up web sites.
Markdown allows you to use these characters naturally, taking care of
all the necessary escaping for you. If you use an ampersand as part of
an HTML entity, it remains unchanged; otherwise it will be translated
into &.
So, if you want to include a copyright symbol in your article, you can write:
©
and Markdown will leave it alone. But if you write:
AT&T
Markdown will translate it to:
AT&T
Similarly, because Markdown supports inline HTML, if you use
angle brackets as delimiters for HTML tags, Markdown will treat them as
such. But if you write:
4 < 5
Markdown will translate it to:
4 < 5
However, inside Markdown code spans and blocks, angle brackets and
ampersands are always encoded automatically. This makes it easy to use
Markdown to write about HTML code. (As opposed to raw HTML, which is a
terrible format for writing about HTML syntax, because every single <
and & in your example code needs to be escaped.)
Block Elements
Paragraphs and Line Breaks
A paragraph is simply one or more consecutive lines of text, separated
by one or more blank lines. (A blank line is any line that looks like a
blank line -- a line containing nothing but spaces or tabs is considered
blank.) Normal paragraphs should not be intended with spaces or tabs.
The implication of the "one or more consecutive lines of text" rule is
that Markdown supports "hard-wrapped" text paragraphs. This differs
significantly from most other text-to-HTML formatters (including Movable
Type's "Convert Line Breaks" option) which translate every line break
character in a paragraph into a <br /> tag.
When you do want to insert a <br /> break tag using Markdown, you
end a line with two or more spaces, then type return.
Yes, this takes a tad more effort to create a <br />, but a simplistic
"every line break is a <br />" rule wouldn't work for Markdown.
Markdown's email-style blockquoting and multi-paragraph list items
work best -- and look better -- when you format them with hard breaks.
Markdown supports two styles of headers, Setext and atx.
Setext-style headers are "underlined" using equal signs (for first-level
headers) and dashes (for second-level headers). For example:
This is an H1
=============
This is an H2
-------------
Any number of underlining ='s or -'s will work.
Atx-style headers use 1-6 hash characters at the start of the line,
corresponding to header levels 1-6. For example:
# This is an H1
## This is an H2
###### This is an H6
Optionally, you may "close" atx-style headers. This is purely
cosmetic -- you can use this if you think it looks better. The
closing hashes don't even need to match the number of hashes
used to open the header. (The number of opening hashes
determines the header level.) :
# This is an H1 #
## This is an H2 ##
### This is an H3 ######
Blockquotes
Markdown uses email-style > characters for blockquoting. If you're
familiar with quoting passages of text in an email message, then you
know how to create a blockquote in Markdown. It looks best if you hard
wrap the text and put a > before every line:
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
>
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
> id sem consectetuer libero luctus adipiscing.
Markdown allows you to be lazy and only put the > before the first
line of a hard-wrapped paragraph:
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
id sem consectetuer libero luctus adipiscing.
Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by
adding additional levels of >:
> This is the first level of quoting.
>
> > This is nested blockquote.
>
> Back to the first level.
Blockquotes can contain other Markdown elements, including headers, lists,
and code blocks:
> ## This is a header.
>
> 1. This is the first list item.
> 2. This is the second list item.
>
> Here's some example code:
>
> return shell_exec("echo $input | $markdown_script");
Any decent text editor should make email-style quoting easy. For
example, with BBEdit, you can make a selection and choose Increase
Quote Level from the Text menu.
Lists
Markdown supports ordered (numbered) and unordered (bulleted) lists.
Unordered lists use asterisks, pluses, and hyphens -- interchangably
-- as list markers:
* Red
* Green
* Blue
is equivalent to:
+ Red
+ Green
+ Blue
and:
- Red
- Green
- Blue
Ordered lists use numbers followed by periods:
1. Bird
2. McHale
3. Parish
It's important to note that the actual numbers you use to mark the
list have no effect on the HTML output Markdown produces. The HTML
Markdown produces from the above list is:
<ol>
<li>Bird</li>
<li>McHale</li>
<li>Parish</li>
</ol>
If you instead wrote the list in Markdown like this:
1. Bird
1. McHale
1. Parish
or even:
3. Bird
1. McHale
8. Parish
you'd get the exact same HTML output. The point is, if you want to,
you can use ordinal numbers in your ordered Markdown lists, so that
the numbers in your source match the numbers in your published HTML.
But if you want to be lazy, you don't have to.
If you do use lazy list numbering, however, you should still start the
list with the number 1. At some point in the future, Markdown may support
starting ordered lists at an arbitrary number.
List markers typically start at the left margin, but may be indented by
up to three spaces. List markers must be followed by one or more spaces
or a tab.
To make lists look nice, you can wrap items with hanging indents:
* Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
* Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.
But if you want to be lazy, you don't have to:
* Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
* Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.
If list items are separated by blank lines, Markdown will wrap the
items in <p> tags in the HTML output. For example, this input:
* Bird
* Magic
will turn into:
<ul>
<li>Bird</li>
<li>Magic</li>
</ul>
But this:
* Bird
* Magic
will turn into:
<ul>
<li><p>Bird</p></li>
<li><p>Magic</p></li>
</ul>
List items may consist of multiple paragraphs. Each subsequent
paragraph in a list item must be intended by either 4 spaces
or one tab:
1. This is a list item with two paragraphs. Lorem ipsum dolor
sit amet, consectetuer adipiscing elit. Aliquam hendrerit
mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet
vitae, risus. Donec sit amet nisl. Aliquam semper ipsum
sit amet velit.
2. Suspendisse id sem consectetuer libero luctus adipiscing.
It looks nice if you indent every line of the subsequent
paragraphs, but here again, Markdown will allow you to be
lazy:
* This is a list item with two paragraphs.
This is the second paragraph in the list item. You're
only required to indent the first line. Lorem ipsum dolor
sit amet, consectetuer adipiscing elit.
* Another item in the same list.
To put a blockquote within a list item, the blockquote's >
delimiters need to be indented:
* A list item with a blockquote:
> This is a blockquote
> inside a list item.
To put a code block within a list item, the code block needs
to be indented twice -- 8 spaces or two tabs:
* A list item with a code block:
<code goes here>
It's worth noting that it's possible to trigger an ordered list by
accident, by writing something like this:
1986. What a great season.
In other words, a number-period-space sequence at the beginning of a
line. To avoid this, you can backslash-escape the period:
1986\. What a great season.
Code Blocks
Pre-formatted code blocks are used for writing about programming or
markup source code. Rather than forming normal paragraphs, the lines
of a code block are interpreted literally. Markdown wraps a code block
in both <pre> and <code> tags.
To produce a code block in Markdown, simply indent every line of the
block by at least 4 spaces or 1 tab. For example, given this input:
This is a normal paragraph:
This is a code block.
Markdown will generate:
<p>This is a normal paragraph:</p>
<pre><code>This is a code block.
</code></pre>
One level of indentation -- 4 spaces or 1 tab -- is removed from each
line of the code block. For example, this:
Here is an example of AppleScript:
tell application "Foo"
beep
end tell
will turn into:
<p>Here is an example of AppleScript:</p>
<pre><code>tell application "Foo"
beep
end tell
</code></pre>
A code block continues until it reaches a line that is not indented
(or the end of the article).
Within a code block, ampersands (&) and angle brackets (< and >)
are automatically converted into HTML entities. This makes it very
easy to include example HTML source code using Markdown -- just paste
it and indent it, and Markdown will handle the hassle of encoding the
ampersands and angle brackets. For example, this:
<div class="footer">
© 2004 Foo Corporation
</div>
will turn into:
<pre><code><div class="footer">
&copy; 2004 Foo Corporation
</div>
</code></pre>
Regular Markdown syntax is not processed within code blocks. E.g.,
asterisks are just literal asterisks within a code block. This means
it's also easy to use Markdown to write about Markdown's own syntax.
Horizontal Rules
You can produce a horizontal rule tag (<hr />) by placing three or
more hyphens, asterisks, or underscores on a line by themselves. If you
wish, you may use spaces between the hyphens or asterisks. Each of the
following lines will produce a horizontal rule:
* * *
***
*****
- - -
---------------------------------------
_ _ _
Span Elements
Links
Markdown supports two style of links: inline and reference.
In both styles, the link text is delimited by [square brackets].
To create an inline link, use a set of regular parentheses immediately
after the link text's closing square bracket. Inside the parentheses,
put the URL where you want the link to point, along with an optional
title for the link, surrounded in quotes. For example:
This is [an example](http://example.com/ "Title") inline link.
[This link](http://example.net/) has no title attribute.
Will produce:
<p>This is <a href="http://example.com/" title="Title">
an example</a> inline link.</p>
<p><a href="http://example.net/">This link</a> has no
title attribute.</p>
If you're referring to a local resource on the same server, you can
use relative paths:
See my [About](/about/) page for details.
Reference-style links use a second set of square brackets, inside
which you place a label of your choosing to identify the link:
This is [an example][id] reference-style link.
You can optionally use a space to separate the sets of brackets:
This is [an example] [id] reference-style link.
Then, anywhere in the document, you define your link label like this,
on a line by itself:
[id]: http://example.com/ "Optional Title Here"
That is:
- Square brackets containing the link identifier (optionally
indented from the left margin using up to three spaces);
- followed by a colon;
- followed by one or more spaces (or tabs);
- followed by the URL for the link;
- optionally followed by a title attribute for the link, enclosed
in double or single quotes.
The link URL may, optionally, be surrounded by angle brackets:
[id]: <http://example.com/> "Optional Title Here"
You can put the title attribute on the next line and use extra spaces
or tabs for padding, which tends to look better with longer URLs:
[id]: http://example.com/longish/path/to/resource/here
"Optional Title Here"
Link definitions are only used for creating links during Markdown
processing, and are stripped from your document in the HTML output.
Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are not case sensitive. E.g. these two links:
[link text][a]
[link text][A]
are equivalent.
The implicit link name shortcut allows you to omit the name of the
link, in which case the link text itself is used as the name.
Just use an empty set of square brackets -- e.g., to link the word
"Google" to the google.com web site, you could simply write:
[Google][]
And then define the link:
[Google]: http://google.com/
Because link names may contain spaces, this shortcut even works for
multiple words in the link text:
Visit [Daring Fireball][] for more information.
And then define the link:
[Daring Fireball]: http://daringfireball.net/
Link definitions can be placed anywhere in your Markdown document. I
tend to put them immediately after each paragraph in which they're
used, but if you want, you can put them all at the end of your
document, sort of like footnotes.
Here's an example of reference links in action:
I get 10 times more traffic from [Google] [1] than from
[Yahoo] [2] or [MSN] [3].
[1]: http://google.com/ "Google"
[2]: http://search.yahoo.com/ "Yahoo Search"
[3]: http://search.msn.com/ "MSN Search"
Using the implicit link name shortcut, you could instead write:
I get 10 times more traffic from [Google][] than from
[Yahoo][] or [MSN][].
[google]: http://google.com/ "Google"
[yahoo]: http://search.yahoo.com/ "Yahoo Search"
[msn]: http://search.msn.com/ "MSN Search"
Both of the above examples will produce the following HTML output:
<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from
<a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a>
or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p>
For comparison, here is the same paragraph written using
Markdown's inline link style:
I get 10 times more traffic from [Google](http://google.com/ "Google")
than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or
[MSN](http://search.msn.com/ "MSN Search").
The point of reference-style links is not that they're easier to
write. The point is that with reference-style links, your document
source is vastly more readable. Compare the above examples: using
reference-style links, the paragraph itself is only 81 characters
long; with inline-style links, it's 176 characters; and as raw HTML,
it's 234 characters. In the raw HTML, there's more markup than there
is text.
With Markdown's reference-style links, a source document much more
closely resembles the final output, as rendered in a browser. By
allowing you to move the markup-related metadata out of the paragraph,
you can add links without interrupting the narrative flow of your
prose.
Emphasis
Markdown treats asterisks (*) and underscores (_) as indicators of
emphasis. Text wrapped with one * or _ will be wrapped with an
HTML <em> tag; double *'s or _'s will be wrapped with an HTML
<strong> tag. E.g., this input:
*single asterisks*
_single underscores_
**double asterisks**
__double underscores__
will produce:
<em>single asterisks</em>
<em>single underscores</em>
<strong>double asterisks</strong>
<strong>double underscores</strong>
You can use whichever style you prefer; the lone restriction is that
the same character must be used to open and close an emphasis span.
Emphasis can be used in the middle of a word:
un*fucking*believable
But if you surround an * or _ with spaces, it'll be treated as a
literal asterisk or underscore.
To produce a literal asterisk or underscore at a position where it
would otherwise be used as an emphasis delimiter, you can backslash
escape it:
\*this text is surrounded by literal asterisks\*
Code
To indicate a span of code, wrap it with backtick quotes (`).
Unlike a pre-formatted code block, a code span indicates code within a
normal paragraph. For example:
Use the `printf()` function.
will produce:
<p>Use the <code>printf()</code> function.</p>
To include a literal backtick character within a code span, you can use
multiple backticks as the opening and closing delimiters:
``There is a literal backtick (`) here.``
which will produce this:
<p><code>There is a literal backtick (`) here.</code></p>
The backtick delimiters surrounding a code span may include spaces --
one after the opening, one before the closing. This allows you to place
literal backtick characters at the beginning or end of a code span:
A single backtick in a code span: `` ` ``
A backtick-delimited string in a code span: `` `foo` ``
will produce:
<p>A single backtick in a code span: <code>`</code></p>
<p>A backtick-delimited string in a code span: <code>`foo`</code></p>
With a code span, ampersands and angle brackets are encoded as HTML
entities automatically, which makes it easy to include example HTML
tags. Markdown will turn this:
Please don't use any `<blink>` tags.
into:
<p>Please don't use any <code><blink></code> tags.</p>
You can write this:
`—` is the decimal-encoded equivalent of `—`.
to produce:
<p><code>&#8212;</code> is the decimal-encoded
equivalent of <code>&mdash;</code>.</p>
Images
Admittedly, it's fairly difficult to devise a "natural" syntax for
placing images into a plain text document format.
Markdown uses an image syntax that is intended to resemble the syntax
for links, allowing for two styles: inline and reference.
Inline image syntax looks like this:
That is:
- An exclamation mark:
!;
- followed by a set of square brackets, containing the
alt
attribute text for the image;
- followed by a set of parentheses, containing the URL or path to
the image, and an optional
title attribute enclosed in double
or single quotes.
Reference-style image syntax looks like this:
![Alt text][id]
Where "id" is the name of a defined image reference. Image references
are defined using syntax identical to link references:
[id]: url/to/image "Optional title attribute"
As of this writing, Markdown has no syntax for specifying the
dimensions of an image; if this is important to you, you can simply
use regular HTML <img> tags.
Miscellaneous
Automatic Links
Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:
<http://example.com/>
Markdown will turn this into:
<a href="http://example.com/">http://example.com/</a>
Automatic links for email addresses work similarly, except that
Markdown will also perform a bit of randomized decimal and hex
entity-encoding to help obscure your address from address-harvesting
spambots. For example, Markdown will turn this:
<address@example.com>
into something like this:
<a href="mailto:addre
ss@example.co
m">address@exa
mple.com</a>
which will render in a browser as a clickable link to "address@example.com".
(This sort of entity-encoding trick will indeed fool many, if not
most, address-harvesting bots, but it definitely won't fool all of
them. It's better than nothing, but an address published in this way
will probably eventually start receiving spam.)
Backslash Escapes
Markdown allows you to use backslash escapes to generate literal
characters which would otherwise have special meaning in Markdown's
formatting syntax. For example, if you wanted to surround a word with
literal asterisks (instead of an HTML <em> tag), you can backslashes
before the asterisks, like this:
\*literal asterisks\*
Markdown provides backslash escapes for the following characters:
\ backslash
` backtick
* asterisk
_ underscore
{} curly braces
[] square brackets
() parentheses
# hash mark
+ plus sign
- minus sign (hyphen)
. dot
! exclamation mark
Markdown-3.1.1/tests/pl/Tests_2004/Nested blockquotes.html 0000644 0000765 0000024 00000000151 13212354257 023665 0 ustar waylan staff 0000000 0000000
foo
bar
foo
Markdown-3.1.1/tests/pl/Tests_2004/Ordered and unordered lists.html 0000644 0000765 0000024 00000003062 13212354257 025331 0 ustar waylan staff 0000000 0000000 Unordered
Asterisks tight:
- asterisk 1
- asterisk 2
- asterisk 3
Asterisks loose:
asterisk 1
asterisk 2
asterisk 3
Pluses tight:
Pluses loose:
Minuses tight:
Minuses loose:
Ordered
Tight:
- First
- Second
- Third
and:
- One
- Two
- Three
Loose using tabs:
First
Second
Third
and using spaces:
One
Two
Three
Multiple paragraphs:
Item 1, graf one.
Item 2. graf two. The quick brown fox jumped over the lazy dog's
back.
Item 2.
Item 3.
Nested
Here's another:
- First
- Second:
- Third
Same thing but with paragraphs:
First
Second:
Third
Markdown-3.1.1/tests/pl/Tests_2004/Strong and em together.html 0000644 0000765 0000024 00000000327 13212354257 024317 0 ustar waylan staff 0000000 0000000 This is strong and em.
So is this word.
This is strong and em.
So is this word.
Markdown-3.1.1/tests/pl/Tests_2004/Tabs.html 0000644 0000765 0000024 00000000667 13212354257 021034 0 ustar waylan staff 0000000 0000000
Code:
this code block is indented by one tab
And:
this code block is indented by two tabs
And:
+ this is an example list item
indented with tabs
+ this is an example list item
indented with spaces
Markdown-3.1.1/tests/pl/Tests_2004/Tidyness.html 0000644 0000765 0000024 00000000205 13212354257 021731 0 ustar waylan staff 0000000 0000000
A list within a blockquote:
- asterisk 1
- asterisk 2
- asterisk 3
Markdown-3.1.1/tests/pl/Tests_2004/Yuri-Attributes.html 0000644 0000765 0000024 00000001511 13212354257 023204 0 ustar waylan staff 0000000 0000000
Lorem ipsum
Dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua.
Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris
nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse
cillum dolore eu fugiat nulla pariatur2. Excepteur sint occaecat
cupidatat non proident, sunt in culpa qui officia deserunt mollit
anim id est laborum.
Duis aute irure dolor in reprehenderit in voluptate
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.
Markdown-3.1.1/tests/pl/Tests_2004/Yuri-Email.html 0000644 0000765 0000024 00000001127 13212354257 022110 0 ustar waylan staff 0000000 0000000
Lorem ipsum yuri@domain.org, etc.
Markdown-3.1.1/tests/pl/Tests_2004/Yuri-Footnotes.html 0000644 0000765 0000024 00000004356 13212354257 023050 0 ustar waylan staff 0000000 0000000
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua1. Ut enim ad minim
veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
commodo consequat. Duis aute irure dolor in reprehenderit in voluptate
velit esse cillum dolore eu fugiat nulla pariatur2. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.
-
Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do
eiusmod tempor incididunt ut labore et dolore3 magna aliqua.
Duis aute irure dolor in reprehenderit in voluptate
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.
Markdown-3.1.1/tests/pl/Tests_2004/Yuri-Links-in-Headers.html 0000644 0000765 0000024 00000000465 13212354257 024122 0 ustar waylan staff 0000000 0000000 A plain header
Let's first have a plain header
An underlined header
(That's also useful)
A header with a link
First with a hash
Another with a link
This time underlined
Markdown-3.1.1/tests/pl/Tests_2007/ 0000755 0000765 0000024 00000000000 13470647777 017271 5 ustar waylan staff 0000000 0000000 Markdown-3.1.1/tests/pl/Tests_2007/Amps and angle encoding.html 0000644 0000765 0000024 00000000771 13212354257 024403 0 ustar waylan staff 0000000 0000000 AT&T has an ampersand in their name.
AT&T is another way to write it.
This & that.
4 < 5.
6 > 5.
Here's a link with an ampersand in the URL.
Here's a link with an amersand in the link text: AT&T.
Here's an inline link.
Here's an inline link.
Markdown-3.1.1/tests/pl/Tests_2007/Auto links.html 0000644 0000765 0000024 00000001042 13212354257 022143 0 ustar waylan staff 0000000 0000000 Link: http://example.com/.
With an ampersand: http://example.com/?foo=1&bar=2
Blockquoted: http://example.com/
Auto-links should not occur here: <http://example.com/>
or here: <http://example.com/>
Markdown-3.1.1/tests/pl/Tests_2007/Backslash escapes.html 0000644 0000765 0000024 00000003261 13212354257 023436 0 ustar waylan staff 0000000 0000000 These should all get escaped:
Backslash: \
Backtick: `
Asterisk: *
Underscore: _
Left brace: {
Right brace: }
Left bracket: [
Right bracket: ]
Left paren: (
Right paren: )
Greater-than: >
Hash: #
Period: .
Bang: !
Plus: +
Minus: -
These should not, because they occur within a code block:
Backslash: \\
Backtick: \`
Asterisk: \*
Underscore: \_
Left brace: \{
Right brace: \}
Left bracket: \[
Right bracket: \]
Left paren: \(
Right paren: \)
Greater-than: \>
Hash: \#
Period: \.
Bang: \!
Plus: \+
Minus: \-
Nor should these, which occur in code spans:
Backslash: \\
Backtick: \`
Asterisk: \*
Underscore: \_
Left brace: \{
Right brace: \}
Left bracket: \[
Right bracket: \]
Left paren: \(
Right paren: \)
Greater-than: \>
Hash: \#
Period: \.
Bang: \!
Plus: \+
Minus: \-
These should get escaped, even though they're matching pairs for
other Markdown constructs:
*asterisks*
_underscores_
`backticks`
This is a code span with a literal backslash-backtick sequence: \`
This is a tag with unescaped backticks bar.
This is a tag with backslashes bar.
Markdown-3.1.1/tests/pl/Tests_2007/Blockquotes with code blocks.html 0000644 0000765 0000024 00000000272 13212354257 025516 0 ustar waylan staff 0000000 0000000
Example:
sub status {
print "working";
}
Or:
sub status {
return "working";
}
Markdown-3.1.1/tests/pl/Tests_2007/Code Blocks.html 0000644 0000765 0000024 00000000470 13212354257 022206 0 ustar waylan staff 0000000 0000000 code block on the first line
Regular text.
code block indented by spaces
Regular text.
the lines in this block
all contain trailing spaces
Regular Text.
code block on the last line
Markdown-3.1.1/tests/pl/Tests_2007/Code Spans.html 0000644 0000765 0000024 00000000336 13212354257 022056 0 ustar waylan staff 0000000 0000000 <test a=" content of attribute ">
Fix for backticks within HTML tag: like this
Here's how you put `backticks` in a code span.
Markdown-3.1.1/tests/pl/Tests_2007/Hard-wrapped paragraphs with list-like lines.html 0000644 0000765 0000024 00000000323 13212354257 030467 0 ustar waylan staff 0000000 0000000 In Markdown 1.0.0 and earlier. Version
8. This line turns into a list item.
Because a hard-wrapped line in the
middle of a paragraph looked like a
list item.
Here's one with a bullet.
* criminey.
Markdown-3.1.1/tests/pl/Tests_2007/Horizontal rules.html 0000644 0000765 0000024 00000000661 13212354257 023404 0 ustar waylan staff 0000000 0000000 Dashes:
---
- - -
Asterisks:
***
* * *
Underscores:
___
_ _ _
Markdown-3.1.1/tests/pl/Tests_2007/Images.html 0000644 0000765 0000024 00000001316 13212354257 021343 0 ustar waylan staff 0000000 0000000 
Inline within a paragraph: alt text.
.
![Empty]()
.jpg)
Markdown-3.1.1/tests/pl/Tests_2007/Inline HTML (Advanced).html 0000644 0000765 0000024 00000000532 13212354257 023707 0 ustar waylan staff 0000000 0000000 Simple block on one line:
foo
And nested without indentation:
And with attributes:
This was broken in 1.0.2b7:
Markdown-3.1.1/tests/pl/Tests_2007/Inline HTML (Simple).html 0000644 0000765 0000024 00000001420 13212354257 023430 0 ustar waylan staff 0000000 0000000 Here's a simple block:
foo
This should be a code block, though:
<div>
foo
</div>
As should this:
<div>foo</div>
Now, nested:
This should just be an HTML comment:
Multiline:
Code block:
<!-- Comment -->
Just plain comment, with trailing spaces on the line:
Code:
<hr />
Hr's:
Markdown-3.1.1/tests/pl/Tests_2007/Inline HTML comments.html 0000644 0000765 0000024 00000000274 13212354257 023711 0 ustar waylan staff 0000000 0000000 Paragraph one.
Paragraph two.
The end.
Markdown-3.1.1/tests/pl/Tests_2007/Links, inline style.html 0000644 0000765 0000024 00000001474 13212354257 023657 0 ustar waylan staff 0000000 0000000 Just a URL.
URL and title.
URL and title.
URL and title.
URL and title.
URL wrapped in angle brackets.
URL w/ angle brackets + title.
Empty.
With parens in the URL
(With outer parens and parens in url)
With parens in the URL
(With outer parens and parens in url)
Markdown-3.1.1/tests/pl/Tests_2007/Links, reference style.html 0000644 0000765 0000024 00000002145 13212354257 024333 0 ustar waylan staff 0000000 0000000 Foo bar.
Foo bar.
Foo bar.
With embedded [brackets].
Indented once.
Indented twice.
Indented thrice.
Indented [four][] times.
[four]: /url
this should work
So should this.
And this.
And this.
And this.
But not [that] [].
Nor [that][].
Nor [that].
[Something in brackets like this should work]
[Same with this.]
In this case, this points to something else.
Backslashing should suppress [this] and [this].
Here's one where the link
breaks across lines.
Here's another where the link
breaks across lines, but with a line-ending space.
Markdown-3.1.1/tests/pl/Tests_2007/Links, shortcut references.html 0000644 0000765 0000024 00000000400 13212354257 025221 0 ustar waylan staff 0000000 0000000 This is the simple case.
This one has a line
break.
This one has a line
break with a line-ending space.
this and the other
Markdown-3.1.1/tests/pl/Tests_2007/Literal quotes in titles.html 0000644 0000765 0000024 00000000243 13212354257 024705 0 ustar waylan staff 0000000 0000000 Foo bar.
Foo bar.
Markdown-3.1.1/tests/pl/Tests_2007/Markdown Documentation - Basics.html 0000644 0000765 0000024 00000022250 13212354257 026014 0 ustar waylan staff 0000000 0000000 Markdown: Basics
Getting the Gist of Markdown's Formatting Syntax
This page offers a brief overview of what it's like to use Markdown.
The syntax page provides complete, detailed documentation for
every feature, but Markdown should be very easy to pick up simply by
looking at a few examples of it in action. The examples on this page
are written in a before/after style, showing example syntax and the
HTML output produced by Markdown.
It's also helpful to simply try Markdown out; the Dingus is a
web application that allows you type your own Markdown-formatted text
and translate it to XHTML.
Note: This document is itself written using Markdown; you
can see the source for it by adding '.text' to the URL.
Paragraphs, Headers, Blockquotes
A paragraph is simply one or more consecutive lines of text, separated
by one or more blank lines. (A blank line is any line that looks like a
blank line -- a line containing nothing spaces or tabs is considered
blank.) Normal paragraphs should not be intended with spaces or tabs.
Markdown offers two styles of headers: Setext and atx.
Setext-style headers for <h1> and <h2> are created by
"underlining" with equal signs (=) and hyphens (-), respectively.
To create an atx-style header, you put 1-6 hash marks (#) at the
beginning of the line -- the number of hashes equals the resulting
HTML header level.
Blockquotes are indicated using email-style '>' angle brackets.
Markdown:
A First Level Header
====================
A Second Level Header
---------------------
Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.
The quick brown fox jumped over the lazy
dog's back.
### Header 3
> This is a blockquote.
>
> This is the second paragraph in the blockquote.
>
> ## This is an H2 in a blockquote
Output:
<h1>A First Level Header</h1>
<h2>A Second Level Header</h2>
<p>Now is the time for all good men to come to
the aid of their country. This is just a
regular paragraph.</p>
<p>The quick brown fox jumped over the lazy
dog's back.</p>
<h3>Header 3</h3>
<blockquote>
<p>This is a blockquote.</p>
<p>This is the second paragraph in the blockquote.</p>
<h2>This is an H2 in a blockquote</h2>
</blockquote>
Phrase Emphasis
Markdown uses asterisks and underscores to indicate spans of emphasis.
Markdown:
Some of these words *are emphasized*.
Some of these words _are emphasized also_.
Use two asterisks for **strong emphasis**.
Or, if you prefer, __use two underscores instead__.
Output:
<p>Some of these words <em>are emphasized</em>.
Some of these words <em>are emphasized also</em>.</p>
<p>Use two asterisks for <strong>strong emphasis</strong>.
Or, if you prefer, <strong>use two underscores instead</strong>.</p>
Lists
Unordered (bulleted) lists use asterisks, pluses, and hyphens (*,
+, and -) as list markers. These three markers are
interchangable; this:
* Candy.
* Gum.
* Booze.
this:
+ Candy.
+ Gum.
+ Booze.
and this:
- Candy.
- Gum.
- Booze.
all produce the same output:
<ul>
<li>Candy.</li>
<li>Gum.</li>
<li>Booze.</li>
</ul>
Ordered (numbered) lists use regular numbers, followed by periods, as
list markers:
1. Red
2. Green
3. Blue
Output:
<ol>
<li>Red</li>
<li>Green</li>
<li>Blue</li>
</ol>
If you put blank lines between items, you'll get <p> tags for the
list item text. You can create multi-paragraph list items by indenting
the paragraphs by 4 spaces or 1 tab:
* A list item.
With multiple paragraphs.
* Another item in the list.
Output:
<ul>
<li><p>A list item.</p>
<p>With multiple paragraphs.</p></li>
<li><p>Another item in the list.</p></li>
</ul>
Links
Markdown supports two styles for creating links: inline and
reference. With both styles, you use square brackets to delimit the
text you want to turn into a link.
Inline-style links use parentheses immediately after the link text.
For example:
This is an [example link](http://example.com/).
Output:
<p>This is an <a href="http://example.com/">
example link</a>.</p>
Optionally, you may include a title attribute in the parentheses:
This is an [example link](http://example.com/ "With a Title").
Output:
<p>This is an <a href="http://example.com/" title="With a Title">
example link</a>.</p>
Reference-style links allow you to refer to your links by names, which
you define elsewhere in your document:
I get 10 times more traffic from [Google][1] than from
[Yahoo][2] or [MSN][3].
[1]: http://google.com/ "Google"
[2]: http://search.yahoo.com/ "Yahoo Search"
[3]: http://search.msn.com/ "MSN Search"
Output:
<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from <a href="http://search.yahoo.com/"
title="Yahoo Search">Yahoo</a> or <a href="http://search.msn.com/"
title="MSN Search">MSN</a>.</p>
The title attribute is optional. Link names may contain letters,
numbers and spaces, but are not case sensitive:
I start my morning with a cup of coffee and
[The New York Times][NY Times].
[ny times]: http://www.nytimes.com/
Output:
<p>I start my morning with a cup of coffee and
<a href="http://www.nytimes.com/">The New York Times</a>.</p>
Images
Image syntax is very much like link syntax.
Inline (titles are optional):
Reference-style:
![alt text][id]
[id]: /path/to/img.jpg "Title"
Both of the above examples produce the same output:
<img src="/path/to/img.jpg" alt="alt text" title="Title" />
Code
In a regular paragraph, you can create code span by wrapping text in
backtick quotes. Any ampersands (&) and angle brackets (< or
>) will automatically be translated into HTML entities. This makes
it easy to use Markdown to write about HTML example code:
I strongly recommend against using any `<blink>` tags.
I wish SmartyPants used named entities like `—`
instead of decimal-encoded entites like `—`.
Output:
<p>I strongly recommend against using any
<code><blink></code> tags.</p>
<p>I wish SmartyPants used named entities like
<code>&mdash;</code> instead of decimal-encoded
entites like <code>&#8212;</code>.</p>
To specify an entire block of pre-formatted code, indent every line of
the block by 4 spaces or 1 tab. Just like with code spans, &, <,
and > characters will be escaped automatically.
Markdown:
If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:
<blockquote>
<p>For example.</p>
</blockquote>
Output:
<p>If you want your page to validate under XHTML 1.0 Strict,
you've got to put paragraph tags in your blockquotes:</p>
<pre><code><blockquote>
<p>For example.</p>
</blockquote>
</code></pre>
Markdown-3.1.1/tests/pl/Tests_2007/Markdown Documentation - Syntax.html 0000644 0000765 0000024 00000076051 13212354257 026106 0 ustar waylan staff 0000000 0000000 Markdown: Syntax
Note: This document is itself written using Markdown; you
can see the source for it by adding '.text' to the URL.
Overview
Philosophy
Markdown is intended to be as easy-to-read and easy-to-write as is feasible.
Readability, however, is emphasized above all else. A Markdown-formatted
document should be publishable as-is, as plain text, without looking
like it's been marked up with tags or formatting instructions. While
Markdown's syntax has been influenced by several existing text-to-HTML
filters -- including Setext, atx, Textile, reStructuredText,
Grutatext, and EtText -- the single biggest source of
inspiration for Markdown's syntax is the format of plain text email.
To this end, Markdown's syntax is comprised entirely of punctuation
characters, which punctuation characters have been carefully chosen so
as to look like what they mean. E.g., asterisks around a word actually
look like *emphasis*. Markdown lists look like, well, lists. Even
blockquotes look like quoted passages of text, assuming you've ever
used email.
Inline HTML
Markdown's syntax is intended for one purpose: to be used as a
format for writing for the web.
Markdown is not a replacement for HTML, or even close to it. Its
syntax is very small, corresponding only to a very small subset of
HTML tags. The idea is not to create a syntax that makes it easier
to insert HTML tags. In my opinion, HTML tags are already easy to
insert. The idea for Markdown is to make it easy to read, write, and
edit prose. HTML is a publishing format; Markdown is a writing
format. Thus, Markdown's formatting syntax only addresses issues that
can be conveyed in plain text.
For any markup that is not covered by Markdown's syntax, you simply
use HTML itself. There's no need to preface it or delimit it to
indicate that you're switching from Markdown to HTML; you just use
the tags.
The only restrictions are that block-level HTML elements -- e.g. <div>,
<table>, <pre>, <p>, etc. -- must be separated from surrounding
content by blank lines, and the start and end tags of the block should
not be indented with tabs or spaces. Markdown is smart enough not
to add extra (unwanted) <p> tags around HTML block-level tags.
For example, to add an HTML table to a Markdown article:
This is a regular paragraph.
<table>
<tr>
<td>Foo</td>
</tr>
</table>
This is another regular paragraph.
Note that Markdown formatting syntax is not processed within block-level
HTML tags. E.g., you can't use Markdown-style *emphasis* inside an
HTML block.
Span-level HTML tags -- e.g. <span>, <cite>, or <del> -- can be
used anywhere in a Markdown paragraph, list item, or header. If you
want, you can even use HTML tags instead of Markdown formatting; e.g. if
you'd prefer to use HTML <a> or <img> tags instead of Markdown's
link or image syntax, go right ahead.
Unlike block-level HTML tags, Markdown syntax is processed within
span-level tags.
Automatic Escaping for Special Characters
In HTML, there are two characters that demand special treatment: <
and &. Left angle brackets are used to start tags; ampersands are
used to denote HTML entities. If you want to use them as literal
characters, you must escape them as entities, e.g. <, and
&.
Ampersands in particular are bedeviling for web writers. If you want to
write about 'AT&T', you need to write 'AT&T'. You even need to
escape ampersands within URLs. Thus, if you want to link to:
http://images.google.com/images?num=30&q=larry+bird
you need to encode the URL as:
http://images.google.com/images?num=30&q=larry+bird
in your anchor tag href attribute. Needless to say, this is easy to
forget, and is probably the single most common source of HTML validation
errors in otherwise well-marked-up web sites.
Markdown allows you to use these characters naturally, taking care of
all the necessary escaping for you. If you use an ampersand as part of
an HTML entity, it remains unchanged; otherwise it will be translated
into &.
So, if you want to include a copyright symbol in your article, you can write:
©
and Markdown will leave it alone. But if you write:
AT&T
Markdown will translate it to:
AT&T
Similarly, because Markdown supports inline HTML, if you use
angle brackets as delimiters for HTML tags, Markdown will treat them as
such. But if you write:
4 < 5
Markdown will translate it to:
4 < 5
However, inside Markdown code spans and blocks, angle brackets and
ampersands are always encoded automatically. This makes it easy to use
Markdown to write about HTML code. (As opposed to raw HTML, which is a
terrible format for writing about HTML syntax, because every single <
and & in your example code needs to be escaped.)
Block Elements
Paragraphs and Line Breaks
A paragraph is simply one or more consecutive lines of text, separated
by one or more blank lines. (A blank line is any line that looks like a
blank line -- a line containing nothing but spaces or tabs is considered
blank.) Normal paragraphs should not be intended with spaces or tabs.
The implication of the "one or more consecutive lines of text" rule is
that Markdown supports "hard-wrapped" text paragraphs. This differs
significantly from most other text-to-HTML formatters (including Movable
Type's "Convert Line Breaks" option) which translate every line break
character in a paragraph into a <br /> tag.
When you do want to insert a <br /> break tag using Markdown, you
end a line with two or more spaces, then type return.
Yes, this takes a tad more effort to create a <br />, but a simplistic
"every line break is a <br />" rule wouldn't work for Markdown.
Markdown's email-style blockquoting and multi-paragraph list items
work best -- and look better -- when you format them with hard breaks.
Markdown supports two styles of headers, Setext and atx.
Setext-style headers are "underlined" using equal signs (for first-level
headers) and dashes (for second-level headers). For example:
This is an H1
=============
This is an H2
-------------
Any number of underlining ='s or -'s will work.
Atx-style headers use 1-6 hash characters at the start of the line,
corresponding to header levels 1-6. For example:
# This is an H1
## This is an H2
###### This is an H6
Optionally, you may "close" atx-style headers. This is purely
cosmetic -- you can use this if you think it looks better. The
closing hashes don't even need to match the number of hashes
used to open the header. (The number of opening hashes
determines the header level.) :
# This is an H1 #
## This is an H2 ##
### This is an H3 ######
Blockquotes
Markdown uses email-style > characters for blockquoting. If you're
familiar with quoting passages of text in an email message, then you
know how to create a blockquote in Markdown. It looks best if you hard
wrap the text and put a > before every line:
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
> consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
> Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
>
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
> id sem consectetuer libero luctus adipiscing.
Markdown allows you to be lazy and only put the > before the first
line of a hard-wrapped paragraph:
> This is a blockquote with two paragraphs. Lorem ipsum dolor sit amet,
consectetuer adipiscing elit. Aliquam hendrerit mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
> Donec sit amet nisl. Aliquam semper ipsum sit amet velit. Suspendisse
id sem consectetuer libero luctus adipiscing.
Blockquotes can be nested (i.e. a blockquote-in-a-blockquote) by
adding additional levels of >:
> This is the first level of quoting.
>
> > This is nested blockquote.
>
> Back to the first level.
Blockquotes can contain other Markdown elements, including headers, lists,
and code blocks:
> ## This is a header.
>
> 1. This is the first list item.
> 2. This is the second list item.
>
> Here's some example code:
>
> return shell_exec("echo $input | $markdown_script");
Any decent text editor should make email-style quoting easy. For
example, with BBEdit, you can make a selection and choose Increase
Quote Level from the Text menu.
Lists
Markdown supports ordered (numbered) and unordered (bulleted) lists.
Unordered lists use asterisks, pluses, and hyphens -- interchangably
-- as list markers:
* Red
* Green
* Blue
is equivalent to:
+ Red
+ Green
+ Blue
and:
- Red
- Green
- Blue
Ordered lists use numbers followed by periods:
1. Bird
2. McHale
3. Parish
It's important to note that the actual numbers you use to mark the
list have no effect on the HTML output Markdown produces. The HTML
Markdown produces from the above list is:
<ol>
<li>Bird</li>
<li>McHale</li>
<li>Parish</li>
</ol>
If you instead wrote the list in Markdown like this:
1. Bird
1. McHale
1. Parish
or even:
3. Bird
1. McHale
8. Parish
you'd get the exact same HTML output. The point is, if you want to,
you can use ordinal numbers in your ordered Markdown lists, so that
the numbers in your source match the numbers in your published HTML.
But if you want to be lazy, you don't have to.
If you do use lazy list numbering, however, you should still start the
list with the number 1. At some point in the future, Markdown may support
starting ordered lists at an arbitrary number.
List markers typically start at the left margin, but may be indented by
up to three spaces. List markers must be followed by one or more spaces
or a tab.
To make lists look nice, you can wrap items with hanging indents:
* Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
* Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.
But if you want to be lazy, you don't have to:
* Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
Aliquam hendrerit mi posuere lectus. Vestibulum enim wisi,
viverra nec, fringilla in, laoreet vitae, risus.
* Donec sit amet nisl. Aliquam semper ipsum sit amet velit.
Suspendisse id sem consectetuer libero luctus adipiscing.
If list items are separated by blank lines, Markdown will wrap the
items in <p> tags in the HTML output. For example, this input:
* Bird
* Magic
will turn into:
<ul>
<li>Bird</li>
<li>Magic</li>
</ul>
But this:
* Bird
* Magic
will turn into:
<ul>
<li><p>Bird</p></li>
<li><p>Magic</p></li>
</ul>
List items may consist of multiple paragraphs. Each subsequent
paragraph in a list item must be intended by either 4 spaces
or one tab:
1. This is a list item with two paragraphs. Lorem ipsum dolor
sit amet, consectetuer adipiscing elit. Aliquam hendrerit
mi posuere lectus.
Vestibulum enim wisi, viverra nec, fringilla in, laoreet
vitae, risus. Donec sit amet nisl. Aliquam semper ipsum
sit amet velit.
2. Suspendisse id sem consectetuer libero luctus adipiscing.
It looks nice if you indent every line of the subsequent
paragraphs, but here again, Markdown will allow you to be
lazy:
* This is a list item with two paragraphs.
This is the second paragraph in the list item. You're
only required to indent the first line. Lorem ipsum dolor
sit amet, consectetuer adipiscing elit.
* Another item in the same list.
To put a blockquote within a list item, the blockquote's >
delimiters need to be indented:
* A list item with a blockquote:
> This is a blockquote
> inside a list item.
To put a code block within a list item, the code block needs
to be indented twice -- 8 spaces or two tabs:
* A list item with a code block:
<code goes here>
It's worth noting that it's possible to trigger an ordered list by
accident, by writing something like this:
1986. What a great season.
In other words, a number-period-space sequence at the beginning of a
line. To avoid this, you can backslash-escape the period:
1986\. What a great season.
Code Blocks
Pre-formatted code blocks are used for writing about programming or
markup source code. Rather than forming normal paragraphs, the lines
of a code block are interpreted literally. Markdown wraps a code block
in both <pre> and <code> tags.
To produce a code block in Markdown, simply indent every line of the
block by at least 4 spaces or 1 tab. For example, given this input:
This is a normal paragraph:
This is a code block.
Markdown will generate:
<p>This is a normal paragraph:</p>
<pre><code>This is a code block.
</code></pre>
One level of indentation -- 4 spaces or 1 tab -- is removed from each
line of the code block. For example, this:
Here is an example of AppleScript:
tell application "Foo"
beep
end tell
will turn into:
<p>Here is an example of AppleScript:</p>
<pre><code>tell application "Foo"
beep
end tell
</code></pre>
A code block continues until it reaches a line that is not indented
(or the end of the article).
Within a code block, ampersands (&) and angle brackets (< and >)
are automatically converted into HTML entities. This makes it very
easy to include example HTML source code using Markdown -- just paste
it and indent it, and Markdown will handle the hassle of encoding the
ampersands and angle brackets. For example, this:
<div class="footer">
© 2004 Foo Corporation
</div>
will turn into:
<pre><code><div class="footer">
&copy; 2004 Foo Corporation
</div>
</code></pre>
Regular Markdown syntax is not processed within code blocks. E.g.,
asterisks are just literal asterisks within a code block. This means
it's also easy to use Markdown to write about Markdown's own syntax.
Horizontal Rules
You can produce a horizontal rule tag (<hr />) by placing three or
more hyphens, asterisks, or underscores on a line by themselves. If you
wish, you may use spaces between the hyphens or asterisks. Each of the
following lines will produce a horizontal rule:
* * *
***
*****
- - -
---------------------------------------
_ _ _
Span Elements
Links
Markdown supports two style of links: inline and reference.
In both styles, the link text is delimited by [square brackets].
To create an inline link, use a set of regular parentheses immediately
after the link text's closing square bracket. Inside the parentheses,
put the URL where you want the link to point, along with an optional
title for the link, surrounded in quotes. For example:
This is [an example](http://example.com/ "Title") inline link.
[This link](http://example.net/) has no title attribute.
Will produce:
<p>This is <a href="http://example.com/" title="Title">
an example</a> inline link.</p>
<p><a href="http://example.net/">This link</a> has no
title attribute.</p>
If you're referring to a local resource on the same server, you can
use relative paths:
See my [About](/about/) page for details.
Reference-style links use a second set of square brackets, inside
which you place a label of your choosing to identify the link:
This is [an example][id] reference-style link.
You can optionally use a space to separate the sets of brackets:
This is [an example] [id] reference-style link.
Then, anywhere in the document, you define your link label like this,
on a line by itself:
[id]: http://example.com/ "Optional Title Here"
That is:
- Square brackets containing the link identifier (optionally
indented from the left margin using up to three spaces);
- followed by a colon;
- followed by one or more spaces (or tabs);
- followed by the URL for the link;
- optionally followed by a title attribute for the link, enclosed
in double or single quotes.
The link URL may, optionally, be surrounded by angle brackets:
[id]: <http://example.com/> "Optional Title Here"
You can put the title attribute on the next line and use extra spaces
or tabs for padding, which tends to look better with longer URLs:
[id]: http://example.com/longish/path/to/resource/here
"Optional Title Here"
Link definitions are only used for creating links during Markdown
processing, and are stripped from your document in the HTML output.
Link definition names may constist of letters, numbers, spaces, and punctuation -- but they are not case sensitive. E.g. these two links:
[link text][a]
[link text][A]
are equivalent.
The implicit link name shortcut allows you to omit the name of the
link, in which case the link text itself is used as the name.
Just use an empty set of square brackets -- e.g., to link the word
"Google" to the google.com web site, you could simply write:
[Google][]
And then define the link:
[Google]: http://google.com/
Because link names may contain spaces, this shortcut even works for
multiple words in the link text:
Visit [Daring Fireball][] for more information.
And then define the link:
[Daring Fireball]: http://daringfireball.net/
Link definitions can be placed anywhere in your Markdown document. I
tend to put them immediately after each paragraph in which they're
used, but if you want, you can put them all at the end of your
document, sort of like footnotes.
Here's an example of reference links in action:
I get 10 times more traffic from [Google] [1] than from
[Yahoo] [2] or [MSN] [3].
[1]: http://google.com/ "Google"
[2]: http://search.yahoo.com/ "Yahoo Search"
[3]: http://search.msn.com/ "MSN Search"
Using the implicit link name shortcut, you could instead write:
I get 10 times more traffic from [Google][] than from
[Yahoo][] or [MSN][].
[google]: http://google.com/ "Google"
[yahoo]: http://search.yahoo.com/ "Yahoo Search"
[msn]: http://search.msn.com/ "MSN Search"
Both of the above examples will produce the following HTML output:
<p>I get 10 times more traffic from <a href="http://google.com/"
title="Google">Google</a> than from
<a href="http://search.yahoo.com/" title="Yahoo Search">Yahoo</a>
or <a href="http://search.msn.com/" title="MSN Search">MSN</a>.</p>
For comparison, here is the same paragraph written using
Markdown's inline link style:
I get 10 times more traffic from [Google](http://google.com/ "Google")
than from [Yahoo](http://search.yahoo.com/ "Yahoo Search") or
[MSN](http://search.msn.com/ "MSN Search").
The point of reference-style links is not that they're easier to
write. The point is that with reference-style links, your document
source is vastly more readable. Compare the above examples: using
reference-style links, the paragraph itself is only 81 characters
long; with inline-style links, it's 176 characters; and as raw HTML,
it's 234 characters. In the raw HTML, there's more markup than there
is text.
With Markdown's reference-style links, a source document much more
closely resembles the final output, as rendered in a browser. By
allowing you to move the markup-related metadata out of the paragraph,
you can add links without interrupting the narrative flow of your
prose.
Emphasis
Markdown treats asterisks (*) and underscores (_) as indicators of
emphasis. Text wrapped with one * or _ will be wrapped with an
HTML <em> tag; double *'s or _'s will be wrapped with an HTML
<strong> tag. E.g., this input:
*single asterisks*
_single underscores_
**double asterisks**
__double underscores__
will produce:
<em>single asterisks</em>
<em>single underscores</em>
<strong>double asterisks</strong>
<strong>double underscores</strong>
You can use whichever style you prefer; the lone restriction is that
the same character must be used to open and close an emphasis span.
Emphasis can be used in the middle of a word:
un*fucking*believable
But if you surround an * or _ with spaces, it'll be treated as a
literal asterisk or underscore.
To produce a literal asterisk or underscore at a position where it
would otherwise be used as an emphasis delimiter, you can backslash
escape it:
\*this text is surrounded by literal asterisks\*
Code
To indicate a span of code, wrap it with backtick quotes (`).
Unlike a pre-formatted code block, a code span indicates code within a
normal paragraph. For example:
Use the `printf()` function.
will produce:
<p>Use the <code>printf()</code> function.</p>
To include a literal backtick character within a code span, you can use
multiple backticks as the opening and closing delimiters:
``There is a literal backtick (`) here.``
which will produce this:
<p><code>There is a literal backtick (`) here.</code></p>
The backtick delimiters surrounding a code span may include spaces --
one after the opening, one before the closing. This allows you to place
literal backtick characters at the beginning or end of a code span:
A single backtick in a code span: `` ` ``
A backtick-delimited string in a code span: `` `foo` ``
will produce:
<p>A single backtick in a code span: <code>`</code></p>
<p>A backtick-delimited string in a code span: <code>`foo`</code></p>
With a code span, ampersands and angle brackets are encoded as HTML
entities automatically, which makes it easy to include example HTML
tags. Markdown will turn this:
Please don't use any `<blink>` tags.
into:
<p>Please don't use any <code><blink></code> tags.</p>
You can write this:
`—` is the decimal-encoded equivalent of `—`.
to produce:
<p><code>&#8212;</code> is the decimal-encoded
equivalent of <code>&mdash;</code>.</p>
Images
Admittedly, it's fairly difficult to devise a "natural" syntax for
placing images into a plain text document format.
Markdown uses an image syntax that is intended to resemble the syntax
for links, allowing for two styles: inline and reference.
Inline image syntax looks like this:
That is:
- An exclamation mark:
!;
- followed by a set of square brackets, containing the
alt
attribute text for the image;
- followed by a set of parentheses, containing the URL or path to
the image, and an optional
title attribute enclosed in double
or single quotes.
Reference-style image syntax looks like this:
![Alt text][id]
Where "id" is the name of a defined image reference. Image references
are defined using syntax identical to link references:
[id]: url/to/image "Optional title attribute"
As of this writing, Markdown has no syntax for specifying the
dimensions of an image; if this is important to you, you can simply
use regular HTML <img> tags.
Miscellaneous
Automatic Links
Markdown supports a shortcut style for creating "automatic" links for URLs and email addresses: simply surround the URL or email address with angle brackets. What this means is that if you want to show the actual text of a URL or email address, and also have it be a clickable link, you can do this:
<http://example.com/>
Markdown will turn this into:
<a href="http://example.com/">http://example.com/</a>
Automatic links for email addresses work similarly, except that
Markdown will also perform a bit of randomized decimal and hex
entity-encoding to help obscure your address from address-harvesting
spambots. For example, Markdown will turn this:
<address@example.com>
into something like this:
<a href="mailto:addre
ss@example.co
m">address@exa
mple.com</a>
which will render in a browser as a clickable link to "address@example.com".
(This sort of entity-encoding trick will indeed fool many, if not
most, address-harvesting bots, but it definitely won't fool all of
them. It's better than nothing, but an address published in this way
will probably eventually start receiving spam.)
Backslash Escapes
Markdown allows you to use backslash escapes to generate literal
characters which would otherwise have special meaning in Markdown's
formatting syntax. For example, if you wanted to surround a word with
literal asterisks (instead of an HTML <em> tag), you can backslashes
before the asterisks, like this:
\*literal asterisks\*
Markdown provides backslash escapes for the following characters:
\ backslash
` backtick
* asterisk
_ underscore
{} curly braces
[] square brackets
() parentheses
# hash mark
+ plus sign
- minus sign (hyphen)
. dot
! exclamation mark
Markdown-3.1.1/tests/pl/Tests_2007/Nested blockquotes.html 0000644 0000765 0000024 00000000151 13212354257 023670 0 ustar waylan staff 0000000 0000000
foo
bar
foo
Markdown-3.1.1/tests/pl/Tests_2007/Ordered and unordered lists.html 0000644 0000765 0000024 00000003245 13212354257 025337 0 ustar waylan staff 0000000 0000000 Unordered
Asterisks tight:
- asterisk 1
- asterisk 2
- asterisk 3
Asterisks loose:
asterisk 1
asterisk 2
asterisk 3
Pluses tight:
Pluses loose:
Minuses tight:
Minuses loose:
Ordered
Tight:
- First
- Second
- Third
and:
- One
- Two
- Three
Loose using tabs:
First
Second
Third
and using spaces:
One
Two
Three
Multiple paragraphs:
Item 1, graf one.
Item 2. graf two. The quick brown fox jumped over the lazy dog's
back.
Item 2.
Item 3.
Nested
Here's another:
- First
- Second:
- Third
Same thing but with paragraphs:
First
Second:
Third
This was an error in Markdown 1.0.1:
Markdown-3.1.1/tests/pl/Tests_2007/Strong and em together.html 0000644 0000765 0000024 00000000327 13212354257 024322 0 ustar waylan staff 0000000 0000000 This is strong and em.
So is this word.
This is strong and em.
So is this word.
Markdown-3.1.1/tests/pl/Tests_2007/Tabs.html 0000644 0000765 0000024 00000000667 13212354257 021037 0 ustar waylan staff 0000000 0000000
Code:
this code block is indented by one tab
And:
this code block is indented by two tabs
And:
+ this is an example list item
indented with tabs
+ this is an example list item
indented with spaces
Markdown-3.1.1/tests/pl/Tests_2007/Tidyness.html 0000644 0000765 0000024 00000000205 13212354257 021734 0 ustar waylan staff 0000000 0000000
A list within a blockquote:
- asterisk 1
- asterisk 2
- asterisk 3
Markdown-3.1.1/tests/test_apis.py 0000644 0000765 0000024 00000111601 13432642364 017432 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
Python-Markdown Regression Tests
================================
Tests of the various APIs with the python markdown lib.
"""
from __future__ import unicode_literals
import unittest
import sys
import os
import markdown
import warnings
from markdown.__main__ import parse_options
from logging import DEBUG, WARNING, CRITICAL
import yaml
import tempfile
from io import BytesIO
from xml.etree.ElementTree import ProcessingInstruction
PY3 = sys.version_info[0] == 3
if not PY3:
def bytes(string, encoding):
return string.encode(encoding)
class TestMarkdownBasics(unittest.TestCase):
""" Tests basics of the Markdown class. """
def setUp(self):
""" Create instance of Markdown. """
self.md = markdown.Markdown()
def testBlankInput(self):
""" Test blank input. """
self.assertEqual(self.md.convert(''), '')
def testWhitespaceOnly(self):
""" Test input of only whitespace. """
self.assertEqual(self.md.convert(' '), '')
def testSimpleInput(self):
""" Test simple input. """
self.assertEqual(self.md.convert('foo'), 'foo
')
def testInstanceExtension(self):
""" Test Extension loading with a class instance. """
from markdown.extensions.footnotes import FootnoteExtension
markdown.Markdown(extensions=[FootnoteExtension()])
def testEntryPointExtension(self):
""" Test Extension loading with an entry point. """
markdown.Markdown(extensions=['footnotes'])
def testDotNotationExtension(self):
""" Test Extension loading with Name (`path.to.module`). """
markdown.Markdown(extensions=['markdown.extensions.footnotes'])
def testDotNotationExtensionWithClass(self):
""" Test Extension loading with class name (`path.to.module:Class`). """
markdown.Markdown(extensions=['markdown.extensions.footnotes:FootnoteExtension'])
class TestConvertFile(unittest.TestCase):
""" Tests of ConvertFile. """
def setUp(self):
self.saved = sys.stdin, sys.stdout
sys.stdin = BytesIO(bytes('foo', encoding='utf-8'))
sys.stdout = BytesIO()
def tearDown(self):
sys.stdin, sys.stdout = self.saved
def getTempFiles(self, src):
""" Return the file names for two temp files. """
infd, infile = tempfile.mkstemp(suffix='.txt')
with os.fdopen(infd, 'w') as fp:
fp.write(src)
outfd, outfile = tempfile.mkstemp(suffix='.html')
return infile, outfile, outfd
def testFileNames(self):
infile, outfile, outfd = self.getTempFiles('foo')
markdown.markdownFromFile(input=infile, output=outfile)
with os.fdopen(outfd, 'r') as fp:
output = fp.read()
self.assertEqual(output, 'foo
')
def testFileObjects(self):
infile = BytesIO(bytes('foo', encoding='utf-8'))
outfile = BytesIO()
markdown.markdownFromFile(input=infile, output=outfile)
outfile.seek(0)
self.assertEqual(outfile.read().decode('utf-8'), 'foo
')
def testStdinStdout(self):
markdown.markdownFromFile()
sys.stdout.seek(0)
self.assertEqual(sys.stdout.read().decode('utf-8'), 'foo
')
class TestBlockParser(unittest.TestCase):
""" Tests of the BlockParser class. """
def setUp(self):
""" Create instance of BlockParser. """
self.parser = markdown.Markdown().parser
def testParseChunk(self):
""" Test BlockParser.parseChunk. """
root = markdown.util.etree.Element("div")
text = 'foo'
self.parser.parseChunk(root, text)
self.assertEqual(
markdown.serializers.to_xhtml_string(root),
""
)
def testParseDocument(self):
""" Test BlockParser.parseDocument. """
lines = ['#foo', '', 'bar', '', ' baz']
tree = self.parser.parseDocument(lines)
self.assertTrue(isinstance(tree, markdown.util.etree.ElementTree))
self.assertTrue(markdown.util.etree.iselement(tree.getroot()))
self.assertEqual(
markdown.serializers.to_xhtml_string(tree.getroot()),
""
)
class TestBlockParserState(unittest.TestCase):
""" Tests of the State class for BlockParser. """
def setUp(self):
self.state = markdown.blockparser.State()
def testBlankState(self):
""" Test State when empty. """
self.assertEqual(self.state, [])
def testSetSate(self):
""" Test State.set(). """
self.state.set('a_state')
self.assertEqual(self.state, ['a_state'])
self.state.set('state2')
self.assertEqual(self.state, ['a_state', 'state2'])
def testIsSate(self):
""" Test State.isstate(). """
self.assertEqual(self.state.isstate('anything'), False)
self.state.set('a_state')
self.assertEqual(self.state.isstate('a_state'), True)
self.state.set('state2')
self.assertEqual(self.state.isstate('state2'), True)
self.assertEqual(self.state.isstate('a_state'), False)
self.assertEqual(self.state.isstate('missing'), False)
def testReset(self):
""" Test State.reset(). """
self.state.set('a_state')
self.state.reset()
self.assertEqual(self.state, [])
self.state.set('state1')
self.state.set('state2')
self.state.reset()
self.assertEqual(self.state, ['state1'])
class TestHtmlStash(unittest.TestCase):
""" Test Markdown's HtmlStash. """
def setUp(self):
self.stash = markdown.util.HtmlStash()
self.placeholder = self.stash.store('foo')
def testSimpleStore(self):
""" Test HtmlStash.store. """
self.assertEqual(self.placeholder, self.stash.get_placeholder(0))
self.assertEqual(self.stash.html_counter, 1)
self.assertEqual(self.stash.rawHtmlBlocks, ['foo'])
def testStoreMore(self):
""" Test HtmlStash.store with additional blocks. """
placeholder = self.stash.store('bar')
self.assertEqual(placeholder, self.stash.get_placeholder(1))
self.assertEqual(self.stash.html_counter, 2)
self.assertEqual(
self.stash.rawHtmlBlocks,
['foo', 'bar']
)
def testReset(self):
""" Test HtmlStash.reset. """
self.stash.reset()
self.assertEqual(self.stash.html_counter, 0)
self.assertEqual(self.stash.rawHtmlBlocks, [])
class Item(object):
""" A dummy Registry item object for testing. """
def __init__(self, data):
self.data = data
def __repr__(self):
return repr(self.data)
def __eq__(self, other):
return self.data == other
class RegistryTests(unittest.TestCase):
""" Test the processor registry. """
def testCreateRegistry(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
self.assertEqual(len(r), 1)
self.assertTrue(isinstance(r, markdown.util.Registry))
def testRegisterWithoutPriority(self):
r = markdown.util.Registry()
with self.assertRaises(TypeError):
r.register(Item('a'))
def testSortRegistry(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b'), 'b', 21)
r.register(Item('c'), 'c', 20.5)
self.assertEqual(len(r), 3)
self.assertEqual(list(r), ['b', 'c', 'a'])
def testIsSorted(self):
r = markdown.util.Registry()
self.assertFalse(r._is_sorted)
r.register(Item('a'), 'a', 20)
list(r)
self.assertTrue(r._is_sorted)
r.register(Item('b'), 'b', 21)
self.assertFalse(r._is_sorted)
r['a']
self.assertTrue(r._is_sorted)
r._is_sorted = False
r.get_index_for_name('a')
self.assertTrue(r._is_sorted)
r._is_sorted = False
repr(r)
self.assertTrue(r._is_sorted)
def testDeregister(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b'), 'b', 30)
r.register(Item('c'), 'c', 40)
self.assertEqual(len(r), 3)
r.deregister('b')
self.assertEqual(len(r), 2)
r.deregister('c', strict=False)
self.assertEqual(len(r), 1)
# deregister non-existant item with strict=False
r.deregister('d', strict=False)
self.assertEqual(len(r), 1)
with self.assertRaises(ValueError):
# deregister non-existant item with strict=True
r.deregister('e')
self.assertEqual(list(r), ['a'])
def testRegistryContains(self):
r = markdown.util.Registry()
item = Item('a')
r.register(item, 'a', 20)
self.assertTrue('a' in r)
self.assertTrue(item in r)
self.assertFalse('b' in r)
def testRegistryIter(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b'), 'b', 30)
self.assertEqual(list(r), ['b', 'a'])
def testRegistryGetItemByIndex(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b'), 'b', 30)
self.assertEqual(r[0], 'b')
self.assertEqual(r[1], 'a')
with self.assertRaises(IndexError):
r[3]
def testRegistryGetItemByItem(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b'), 'b', 30)
self.assertEqual(r['a'], 'a')
self.assertEqual(r['b'], 'b')
with self.assertRaises(KeyError):
r['c']
def testRegistrySetItem(self):
r = markdown.util.Registry()
with self.assertRaises(TypeError):
r[0] = 'a'
# TODO: restore this when deprecated __setitem__ is removed.
# with self.assertRaises(TypeError):
# r['a'] = 'a'
# TODO: remove this when deprecated __setitem__ is removed.
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
r['a'] = Item('a')
self.assertEqual(list(r), ['a'])
r['b'] = Item('b')
self.assertEqual(list(r), ['a', 'b'])
r['a'] = Item('a1')
self.assertEqual(list(r), ['a1', 'b'])
# Check the warnings
self.assertEqual(len(w), 3)
self.assertTrue(all(issubclass(x.category, DeprecationWarning) for x in w))
def testRegistryDelItem(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
with self.assertRaises(TypeError):
del r[0]
# TODO: restore this when deprecated __del__ is removed.
# with self.assertRaises(TypeError):
# del r['a']
# TODO: remove this when deprecated __del__ is removed.
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
r.register(Item('b'), 'b', 15)
r.register(Item('c'), 'c', 10)
del r['b']
self.assertEqual(list(r), ['a', 'c'])
del r['a']
self.assertEqual(list(r), ['c'])
with self.assertRaises(TypeError):
del r['badname']
del r['c']
self.assertEqual(list(r), [])
# Check the warnings
self.assertEqual(len(w), 3)
self.assertTrue(all(issubclass(x.category, DeprecationWarning) for x in w))
def testRegistrySlice(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b'), 'b', 30)
r.register(Item('c'), 'c', 40)
slc = r[1:]
self.assertEqual(len(slc), 2)
self.assertTrue(isinstance(slc, markdown.util.Registry))
self.assertEqual(list(slc), ['b', 'a'])
def testGetIndexForName(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b'), 'b', 30)
self.assertEqual(r.get_index_for_name('a'), 1)
self.assertEqual(r.get_index_for_name('b'), 0)
with self.assertRaises(ValueError):
r.get_index_for_name('c')
def testRegisterDupplicate(self):
r = markdown.util.Registry()
r.register(Item('a'), 'a', 20)
r.register(Item('b1'), 'b', 10)
self.assertEqual(list(r), ['a', 'b1'])
self.assertEqual(len(r), 2)
r.register(Item('b2'), 'b', 30)
self.assertEqual(len(r), 2)
self.assertEqual(list(r), ['b2', 'a'])
def testRegistryDeprecatedAdd(self):
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
r = markdown.util.Registry()
# Add first item
r.add('c', Item('c'), '_begin')
self.assertEqual(list(r), ['c'])
# Added to beginning
r.add('b', Item('b'), '_begin')
self.assertEqual(list(r), ['b', 'c'])
# Add before first item
r.add('a', Item('a'), 'b')
self.assertEqual(list(r), ['a', 'a1', 'b', 'b1', 'c'])
# Add after last item
r.add('d', Item('d'), '>c')
self.assertEqual(list(r), ['a', 'a1', 'b', 'b1', 'c', 'd'])
# Add to end
r.add('e', Item('e'), '_end')
self.assertEqual(list(r), ['a', 'a1', 'b', 'b1', 'c', 'd', 'e'])
with self.assertRaises(ValueError):
r.add('f', Item('f'), 'badlocation')
# Check the warnings
self.assertEqual(len(w), 7)
self.assertTrue(all(issubclass(x.category, DeprecationWarning) for x in w))
class TestErrors(unittest.TestCase):
""" Test Error Reporting. """
def setUp(self):
# Set warnings to be raised as errors
warnings.simplefilter('error')
def tearDown(self):
# Reset warning behavior back to default
warnings.simplefilter('default')
def testNonUnicodeSource(self):
""" Test falure on non-unicode source text. """
if not PY3:
source = "foo".encode('utf-16')
self.assertRaises(UnicodeDecodeError, markdown.markdown, source)
def testBadOutputFormat(self):
""" Test failure on bad output_format. """
self.assertRaises(KeyError, markdown.Markdown, output_format='invalid')
def testLoadExtensionFailure(self):
""" Test failure of an extension to load. """
self.assertRaises(
ImportError,
markdown.Markdown, extensions=['non_existant_ext']
)
def testLoadBadExtension(self):
""" Test loading of an Extension with no makeExtension function. """
self.assertRaises(AttributeError, markdown.Markdown, extensions=['markdown.util'])
def testNonExtension(self):
""" Test loading a non Extension object as an extension. """
self.assertRaises(TypeError, markdown.Markdown, extensions=[object])
def testDotNotationExtensionWithBadClass(self):
""" Test Extension loading with non-existant class name (`path.to.module:Class`). """
self.assertRaises(
AttributeError,
markdown.Markdown,
extensions=['markdown.extensions.footnotes:MissingExtension']
)
def testBaseExtention(self):
""" Test that the base Extension class will raise NotImplemented. """
self.assertRaises(
NotImplementedError,
markdown.Markdown, extensions=[markdown.extensions.Extension()]
)
class testETreeComments(unittest.TestCase):
"""
Test that ElementTree Comments work.
These tests should only be a concern when using cElementTree with third
party serializers (including markdown's (x)html serializer). While markdown
doesn't use ElementTree.Comment itself, we should certainly support any
third party extensions which may. Therefore, these tests are included to
ensure such support is maintained.
"""
def setUp(self):
# Create comment node
self.comment = markdown.util.etree.Comment('foo')
if hasattr(markdown.util.etree, 'test_comment'):
self.test_comment = markdown.util.etree.test_comment
else:
self.test_comment = markdown.util.etree.Comment
def testCommentIsComment(self):
""" Test that an ElementTree Comment passes the `is Comment` test. """
self.assertTrue(self.comment.tag is markdown.util.etree.test_comment)
def testCommentIsBlockLevel(self):
""" Test that an ElementTree Comment is recognized as BlockLevel. """
md = markdown.Markdown()
self.assertFalse(md.is_block_level(self.comment.tag))
def testCommentSerialization(self):
""" Test that an ElementTree Comment serializes properly. """
self.assertEqual(
markdown.serializers.to_html_string(self.comment),
''
)
def testCommentPrettify(self):
""" Test that an ElementTree Comment is prettified properly. """
pretty = markdown.treeprocessors.PrettifyTreeprocessor(markdown.Markdown())
pretty.run(self.comment)
self.assertEqual(
markdown.serializers.to_html_string(self.comment),
'\n'
)
class testElementTailTests(unittest.TestCase):
""" Element Tail Tests """
def setUp(self):
self.pretty = markdown.treeprocessors.PrettifyTreeprocessor(markdown.Markdown())
def testBrTailNoNewline(self):
""" Test that last
in tree has a new line tail """
root = markdown.util.etree.Element('root')
br = markdown.util.etree.SubElement(root, 'br')
self.assertEqual(br.tail, None)
self.pretty.run(root)
self.assertEqual(br.tail, "\n")
class testSerializers(unittest.TestCase):
""" Test the html and xhtml serializers. """
def testHtml(self):
""" Test HTML serialization. """
el = markdown.util.etree.Element('div')
el.set('id', 'foo<&">')
p = markdown.util.etree.SubElement(el, 'p')
p.text = 'foo <&escaped>'
p.set('hidden', 'hidden')
markdown.util.etree.SubElement(el, 'hr')
non_element = markdown.util.etree.SubElement(el, None)
non_element.text = 'non-element text'
script = markdown.util.etree.SubElement(non_element, 'script')
script.text = '<&"test\nescaping">'
el.tail = "tail text"
self.assertEqual(
markdown.serializers.to_html_string(el),
''
'
foo <&escaped>
'
'
'
'non-element text'
''
'
'
'
foo<&escaped>
'
'
'
'non-element text'
''
'
'
)
def testProsessingInstruction(self):
""" Test serialization of ProcessignInstruction. """
pi = ProcessingInstruction('foo', text='<&"test\nescaping">')
self.assertIs(pi.tag, ProcessingInstruction)
self.assertEqual(
markdown.serializers.to_xhtml_string(pi),
''
)
def testQNameTag(self):
""" Test serialization of QName tag. """
div = markdown.util.etree.Element('div')
qname = markdown.util.etree.QName('http://www.w3.org/1998/Math/MathML', 'math')
math = markdown.util.etree.SubElement(div, qname)
math.set('display', 'block')
sem = markdown.util.etree.SubElement(math, 'semantics')
msup = markdown.util.etree.SubElement(sem, 'msup')
mi = markdown.util.etree.SubElement(msup, 'mi')
mi.text = 'x'
mn = markdown.util.etree.SubElement(msup, 'mn')
mn.text = '2'
ann = markdown.util.etree.SubElement(sem, 'annotations')
ann.text = 'x^2'
self.assertEqual(
markdown.serializers.to_xhtml_string(div),
''
'
'
'
foo
'
)
def testXHTMLOutput(self):
self.assertEqual(
markdown.markdown('foo \nbar', output_format='xhtml'),
'foo
\nbar
'
)
def testHTMLOutput(self):
self.assertEqual(
markdown.markdown('foo \nbar', output_format='html'),
'foo
\nbar
'
)
class testAtomicString(unittest.TestCase):
""" Test that AtomicStrings are honored (not parsed). """
def setUp(self):
md = markdown.Markdown()
self.inlineprocessor = md.treeprocessors['inline']
def testString(self):
""" Test that a regular string is parsed. """
tree = markdown.util.etree.Element('div')
p = markdown.util.etree.SubElement(tree, 'p')
p.text = 'some *text*'
new = self.inlineprocessor.run(tree)
self.assertEqual(
markdown.serializers.to_html_string(new),
''
)
def testSimpleAtomicString(self):
""" Test that a simple AtomicString is not parsed. """
tree = markdown.util.etree.Element('div')
p = markdown.util.etree.SubElement(tree, 'p')
p.text = markdown.util.AtomicString('some *text*')
new = self.inlineprocessor.run(tree)
self.assertEqual(
markdown.serializers.to_html_string(new),
''
)
def testNestedAtomicString(self):
""" Test that a nested AtomicString is not parsed. """
tree = markdown.util.etree.Element('div')
p = markdown.util.etree.SubElement(tree, 'p')
p.text = markdown.util.AtomicString('*some* ')
span1 = markdown.util.etree.SubElement(p, 'span')
span1.text = markdown.util.AtomicString('*more* ')
span2 = markdown.util.etree.SubElement(span1, 'span')
span2.text = markdown.util.AtomicString('*text* ')
span3 = markdown.util.etree.SubElement(span2, 'span')
span3.text = markdown.util.AtomicString('*here*')
span3.tail = markdown.util.AtomicString(' *to*')
span2.tail = markdown.util.AtomicString(' *test*')
span1.tail = markdown.util.AtomicString(' *with*')
new = self.inlineprocessor.run(tree)
self.assertEqual(
markdown.serializers.to_html_string(new),
'*some* *more* *text* *here* '
'*to* *test* *with*
Some test and a +link+
"""
self.md.reset()
self.assertEqual(self.md.convert(test), result)
def test_ancestors_tail(self):
""" Test that an extension can exclude parent tags when dealing with a tail. """
test = """
[***+em+*+strong+**](http://test.com)
"""
result = """+em++strong+
"""
self.md.reset()
self.assertEqual(self.md.convert(test), result)
class TestGeneralDeprecations(unittest.TestCase):
"""Test general deprecations."""
def test_version_deprecation(self):
"""Test that version is deprecated."""
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Trigger a warning.
version = markdown.version
# Verify some things
self.assertTrue(len(w) == 1)
self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
self.assertEqual(version, markdown.__version__)
def test_version_info_deprecation(self):
"""Test that version info is deprecated."""
with warnings.catch_warnings(record=True) as w:
# Cause all warnings to always be triggered.
warnings.simplefilter("always")
# Trigger a warning.
version_info = markdown.version_info
# Verify some things
self.assertTrue(len(w) == 1)
self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
self.assertEqual(version_info, markdown.__version_info__)
def test_deprecation_wrapper_dir(self):
"""Tests the `__dir__` attribute of the class as it replaces the module's."""
dir_attr = dir(markdown)
self.assertFalse('version' in dir_attr)
self.assertTrue('__version__' in dir_attr)
self.assertFalse('version_info' in dir_attr)
self.assertTrue('__version_info__' in dir_attr)
Markdown-3.1.1/tests/test_extensions.py 0000644 0000765 0000024 00000124012 13440325655 020675 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
Python-Markdown Extension Regression Tests
==========================================
A collection of regression tests to confirm that the included extensions
continue to work as advertised. This used to be accomplished by doctests.
"""
from __future__ import unicode_literals
import unittest
import markdown
class TestCaseWithAssertStartsWith(unittest.TestCase):
def assertStartsWith(self, expectedPrefix, text, msg=None):
if not text.startswith(expectedPrefix):
if len(expectedPrefix) + 5 < len(text):
text = text[:len(expectedPrefix) + 5] + '...'
standardMsg = '%s not found at the start of %s' % (repr(expectedPrefix),
repr(text))
self.fail(self._formatMessage(msg, standardMsg))
class TestExtensionClass(unittest.TestCase):
""" Test markdown.extensions.Extension. """
def setUp(self):
class TestExtension(markdown.extensions.Extension):
config = {
'foo': ['bar', 'Description of foo'],
'bar': ['baz', 'Description of bar']
}
self.ext = TestExtension()
self.ExtKlass = TestExtension
def testGetConfig(self):
self.assertEqual(self.ext.getConfig('foo'), 'bar')
def testGetConfigDefault(self):
self.assertEqual(self.ext.getConfig('baz'), '')
self.assertEqual(self.ext.getConfig('baz', default='missing'), 'missing')
def testGetConfigs(self):
self.assertEqual(self.ext.getConfigs(), {'foo': 'bar', 'bar': 'baz'})
def testGetConfigInfo(self):
self.assertEqual(
dict(self.ext.getConfigInfo()),
dict([
('foo', 'Description of foo'),
('bar', 'Description of bar')
])
)
def testSetConfig(self):
self.ext.setConfig('foo', 'baz')
self.assertEqual(self.ext.getConfigs(), {'foo': 'baz', 'bar': 'baz'})
def testSetConfigWithBadKey(self):
# self.ext.setConfig('bad', 'baz) ==> KeyError
self.assertRaises(KeyError, self.ext.setConfig, 'bad', 'baz')
def testConfigAsKwargsOnInit(self):
ext = self.ExtKlass(foo='baz', bar='blah')
self.assertEqual(ext.getConfigs(), {'foo': 'baz', 'bar': 'blah'})
class TestAbbr(unittest.TestCase):
""" Test abbr extension. """
def setUp(self):
self.md = markdown.Markdown(extensions=['abbr'])
def testSimpleAbbr(self):
""" Test Abbreviations. """
text = 'Some text with an ABBR and a REF. Ignore REFERENCE and ref.' + \
'\n\n*[ABBR]: Abbreviation\n' + \
'*[REF]: Abbreviation Reference'
self.assertEqual(
self.md.convert(text),
'Some text with an ABBR '
'and a REF. Ignore '
'REFERENCE and ref.
'
)
def testNestedAbbr(self):
""" Test Nested Abbreviations. """
text = '[ABBR](/foo) and _ABBR_\n\n' + \
'*[ABBR]: Abreviation'
self.assertEqual(
self.md.convert(text),
'ABBR '
'and ABBR
'
)
class TestCodeHilite(TestCaseWithAssertStartsWith):
""" Test codehilite extension. """
def setUp(self):
self.has_pygments = True
try:
import pygments # noqa
except ImportError:
self.has_pygments = False
def testBasicCodeHilite(self):
text = '\t# A Code Comment'
md = markdown.Markdown(extensions=['codehilite'])
if self.has_pygments:
# Pygments can use random lexer here as we did not specify the language
self.assertStartsWith('', md.convert(text))
else:
self.assertEqual(
md.convert(text),
'# A Code Comment'
'
'
)
def testLinenumsTrue(self):
text = '\t# A Code Comment'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension(linenums=True)])
if self.has_pygments:
# Different versions of pygments output slightly different markup.
# So we use 'startwith' and test just enough to confirm that
# pygments received and processed linenums.
self.assertStartsWith(
'',
md.convert(text)
)
else:
self.assertEqual(
md.convert(text),
'# A Code Comment'
'
'
)
def testLinenumsFalse(self):
text = '\t#!Python\n\t# A Code Comment'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension(linenums=False)])
if self.has_pygments:
self.assertStartsWith('# A Code Comment'
'
'
)
def testLinenumsNone(self):
text = '\t# A Code Comment'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension(linenums=None)])
if self.has_pygments:
# Pygments can use random lexer here as we did not specify the language
self.assertStartsWith(' ', md.convert(text))
else:
self.assertEqual(
md.convert(text),
'# A Code Comment'
'
'
)
def testLinenumsNoneWithShebang(self):
text = '\t#!Python\n\t# A Code Comment'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension(linenums=None)])
if self.has_pygments:
# Differant versions of pygments output slightly different markup.
# So we use 'startwith' and test just enough to confirm that
# pygments received and processed linenums.
self.assertStartsWith(
'',
md.convert(text)
)
else:
self.assertEqual(
md.convert(text),
'# A Code Comment'
'
'
)
def testLinenumsNoneWithColon(self):
text = '\t:::Python\n\t# A Code Comment'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension(linenums=None)]
)
if self.has_pygments:
self.assertStartsWith('# A Code Comment'
'
'
)
def testHighlightLinesWithColon(self):
# Test with hl_lines delimited by single or double quotes.
text0 = '\t:::Python hl_lines="1"\n\t#line 1\n\t#line 2\n\t#line 3'
text1 = "\t:::Python hl_lines='1'\n\t#line 1\n\t#line 2\n\t#line 3"
for text in (text0, text1):
md = markdown.Markdown(extensions=['codehilite'])
if self.has_pygments:
self.assertStartsWith(
' ', '')
)
else:
self.assertEqual(
md.convert(text),
''
'#line 1\n'
'#line 2\n'
'#line 3'
)
def testUsePygmentsFalse(self):
text = '\t:::Python\n\t# A Code Comment'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension(use_pygments=False)]
)
self.assertEqual(
md.convert(text),
'# A Code Comment'
'
'
)
def testDoubleEscape(self):
""" Test entity escape logic in indented code blocks. """
text = '\t:::html\n\tThis&That'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension()]
)
if self.has_pygments:
self.assertEqual(
md.convert(text),
''
''
'<span>'
'This&That'
'</span>'
'\n'
'<span>This&That</span>'
'
'
)
def testHighlightAmps(self):
""" Test amp conversion logic. """
text = '\t:::text\n\t&\n\t&\n\t&'
md = markdown.Markdown(
extensions=[markdown.extensions.codehilite.CodeHiliteExtension()]
)
if self.has_pygments:
self.assertEqual(
md.convert(text),
''
)
else:
self.assertEqual(
md.convert(text),
'&\n&\n&amp;
'
)
class TestFencedCode(TestCaseWithAssertStartsWith):
""" Test fenced_code extension. """
def setUp(self):
self.md = markdown.Markdown(extensions=['fenced_code'])
self.has_pygments = True
try:
import pygments # noqa
except ImportError:
self.has_pygments = False
def testBasicFence(self):
""" Test Fenced Code Blocks. """
text = '''
A paragraph before a fenced code block:
~~~
Fenced code block
~~~'''
self.assertEqual(
self.md.convert(text),
'A paragraph before a fenced code block: \n'
'Fenced code block\n'
'
'
)
def testSafeFence(self):
""" Test Fenced Code with safe_mode. """
text = '~~~\nCode\n~~~'
self.md.safeMode = 'replace'
self.assertEqual(
self.md.convert(text),
'Code\n'
'
'
)
def testNestedFence(self):
""" Test nested fence. """
text = '''
~~~~~~~~
~~~~
~~~~~~~~'''
self.assertEqual(
self.md.convert(text),
'\n'
'~~~~\n'
'
'
)
def testFencedLanguage(self):
""" Test Language Tags. """
text = '''
~~~~{.python}
# Some python code
~~~~'''
self.assertEqual(
self.md.convert(text),
'# Some python code\n'
'
'
)
def testFencedBackticks(self):
""" Test Code Fenced with Backticks. """
text = '''
`````
# Arbitrary code
~~~~~ # these tildes will not close the block
`````'''
self.assertEqual(
self.md.convert(text),
'# Arbitrary code\n'
'~~~~~ # these tildes will not close the block\n'
'
'
)
def testFencedCodeWithHighlightLines(self):
""" Test Fenced Code with Highlighted Lines. """
text = '''
```hl_lines="1 3"
line 1
line 2
line 3
```'''
md = markdown.Markdown(
extensions=[
markdown.extensions.codehilite.CodeHiliteExtension(linenums=None, guess_lang=False),
'fenced_code'
]
)
if self.has_pygments:
self.assertStartsWith(
'', '')
)
else:
self.assertEqual(
md.convert(text),
'line 1\n'
'line 2\n'
'line 3
'
)
def testFencedLanguageAndHighlightLines(self):
""" Test Fenced Code with Highlighted Lines. """
text0 = '''
```.python hl_lines="1 3"
#line 1
#line 2
#line 3
```'''
text1 = '''
~~~{.python hl_lines='1 3'}
#line 1
#line 2
#line 3
~~~'''
for text in (text0, text1):
md = markdown.Markdown(
extensions=[
markdown.extensions.codehilite.CodeHiliteExtension(linenums=None, guess_lang=False),
'fenced_code'
]
)
if self.has_pygments:
self.assertStartsWith(
'', '')
)
else:
self.assertEqual(
md.convert(text),
'#line 1\n'
'#line 2\n'
'#line 3
'
)
def testFencedLanguageAndPygmentsDisabled(self):
""" Test if fenced_code honors CodeHilite option use_pygments=False. """
text = '```python\nfrom __future__ import braces\n```'
md = markdown.Markdown(
extensions=[
markdown.extensions.codehilite.CodeHiliteExtension(use_pygments=False),
'fenced_code'
]
)
self.assertTrue('' in md.convert(text))
def testFencedLanguageDoubleEscape(self):
""" Test entity escape logic in fences. """
text = '```html\nThis&That\n```'
md = markdown.Markdown(
extensions=[
markdown.extensions.codehilite.CodeHiliteExtension(),
'fenced_code'
]
)
if self.has_pygments:
self.assertEqual(
md.convert(text),
''
''
'<span>'
'This&That'
'</span>'
'\n'
'<span>This&That</span>'
'
'
)
def testFencedAmps(self):
""" Test amp conversion. """
text = '```text\n&\n&\n&\n```'
md = markdown.Markdown(
extensions=[
markdown.extensions.codehilite.CodeHiliteExtension(),
'fenced_code'
]
)
if self.has_pygments:
self.assertEqual(
md.convert(text),
''
)
else:
self.assertEqual(
md.convert(text),
'&\n&\n&amp;
'
)
class TestMetaData(unittest.TestCase):
""" Test MetaData extension. """
def setUp(self):
self.md = markdown.Markdown(extensions=['meta'])
def testBasicMetaData(self):
""" Test basic metadata. """
text = '''Title: A Test Doc.
Author: Waylan Limberg
John Doe
Blank_Data:
The body. This is paragraph one.'''
self.assertEqual(
self.md.convert(text),
'The body. This is paragraph one. '
)
self.assertEqual(
self.md.Meta, {
'author': ['Waylan Limberg', 'John Doe'],
'blank_data': [''],
'title': ['A Test Doc.']
}
)
def testYamlMetaData(self):
""" Test metadata specified as simple YAML. """
text = '''---
Title: A Test Doc.
Author: [Waylan Limberg, John Doe]
Blank_Data:
---
The body. This is paragraph one.'''
self.assertEqual(
self.md.convert(text),
'The body. This is paragraph one. '
)
self.assertEqual(
self.md.Meta, {
'author': ['[Waylan Limberg, John Doe]'],
'blank_data': [''],
'title': ['A Test Doc.']
}
)
def testMissingMetaData(self):
""" Test document without Meta Data. """
text = ' Some Code - not extra lines of meta data.'
self.assertEqual(
self.md.convert(text),
'Some Code - not extra lines of meta data.\n'
'
'
)
self.assertEqual(self.md.Meta, {})
def testMetaDataWithoutNewline(self):
""" Test doocument with only metadata and no newline at end."""
text = 'title: No newline'
self.assertEqual(self.md.convert(text), '')
self.assertEqual(self.md.Meta, {'title': ['No newline']})
def testMetaDataReset(self):
""" Test that reset call remove Meta entirely """
text = '''Title: A Test Doc.
Author: Waylan Limberg
John Doe
Blank_Data:
The body. This is paragraph one.'''
self.md.convert(text)
self.md.reset()
self.assertEqual(self.md.Meta, {})
class TestWikiLinks(unittest.TestCase):
""" Test Wikilinks Extension. """
def setUp(self):
self.md = markdown.Markdown(extensions=['wikilinks'])
self.text = "Some text with a [[WikiLink]]."
def testBasicWikilinks(self):
""" Test [[wikilinks]]. """
self.assertEqual(
self.md.convert(self.text),
'Some text with a '
'WikiLink. '
)
def testWikilinkWhitespace(self):
""" Test whitespace in wikilinks. """
self.assertEqual(
self.md.convert('[[ foo bar_baz ]]'),
'foo bar_baz '
)
self.assertEqual(
self.md.convert('foo [[ ]] bar'),
'foo bar '
)
def testSimpleSettings(self):
""" Test Simple Settings. """
self.assertEqual(markdown.markdown(
self.text, extensions=[
markdown.extensions.wikilinks.WikiLinkExtension(
base_url='/wiki/',
end_url='.html',
html_class='foo')
]
),
'Some text with a '
'WikiLink. ')
def testComplexSettings(self):
""" Test Complex Settings. """
md = markdown.Markdown(
extensions=['wikilinks'],
extension_configs={
'wikilinks': [
('base_url', 'http://example.com/'),
('end_url', '.html'),
('html_class', '')
]
},
safe_mode=True
)
self.assertEqual(
md.convert(self.text),
'Some text with a '
'WikiLink. '
)
def testWikilinksMetaData(self):
""" test MetaData with Wikilinks Extension. """
text = """wiki_base_url: http://example.com/
wiki_end_url: .html
wiki_html_class:
Some text with a [[WikiLink]]."""
md = markdown.Markdown(extensions=['meta', 'wikilinks'])
self.assertEqual(
md.convert(text),
'Some text with a '
'WikiLink. '
)
# MetaData should not carry over to next document:
self.assertEqual(
md.convert("No [[MetaData]] here."),
'No MetaData '
'here. '
)
def testURLCallback(self):
""" Test used of a custom URL builder. """
from markdown.extensions.wikilinks import WikiLinkExtension
def my_url_builder(label, base, end):
return '/bar/'
md = markdown.Markdown(extensions=[WikiLinkExtension(build_url=my_url_builder)])
self.assertEqual(
md.convert('[[foo]]'),
'foo '
)
class TestAdmonition(unittest.TestCase):
""" Test Admonition Extension. """
def setUp(self):
self.md = markdown.Markdown(extensions=['admonition'])
def testRE(self):
RE = self.md.parser.blockprocessors['admonition'].RE
tests = [
('!!! note', ('note', None)),
('!!! note "Please Note"', ('note', 'Please Note')),
('!!! note ""', ('note', '')),
]
for test, expected in tests:
self.assertEqual(RE.match(test).groups(), expected)
class TestTOC(TestCaseWithAssertStartsWith):
""" Test TOC Extension. """
def setUp(self):
self.md = markdown.Markdown(extensions=['toc'])
def testMarker(self):
""" Test TOC with a Marker. """
text = '[TOC]\n\n# Header 1\n\n## Header 2'
self.assertEqual(
self.md.convert(text),
'\n'
' \n' # noqa
'- Header 1' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' \n'
' \n' # noqa
'- Header 1' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' \n'
' \n' # noqa
'- Header 1' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' [TOC] \n'
'\n'
''
)
self.assertStartsWith('', md.toc)
def testReset(self):
""" Test TOC Reset. """
self.assertEqual(self.md.toc, '')
self.md.convert('# Header 1\n\n## Header 2')
self.assertStartsWith(' ', self.md.toc)
self.md.reset()
self.assertEqual(self.md.toc, '')
def testUniqueIds(self):
""" Test Unique IDs. """
text = '#Header\n#Header\n#Header'
self.assertEqual(
self.md.convert(text),
'\n'
'\n'
''
)
def testHtmlEntities(self):
""" Test Headers with HTML Entities. """
text = '# Foo & bar'
self.assertEqual(
self.md.convert(text),
' Foo & bar'
)
def testRawHtml(self):
""" Test Headers with raw HTML. """
text = '# Foo Bar Baz.'
self.assertEqual(
self.md.convert(text),
' Foo Bar Baz.'
)
def testBaseLevel(self):
""" Test Header Base Level. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(baselevel=5)]
)
text = '# Some Header\n\n## Next Level\n\n### Too High'
self.assertEqual(
md.convert(text),
'\n'
' Next Level\n'
' Too High'
)
self.assertEqual(
md.toc,
' \n'
' \n' # noqa
'- Some Header' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' \n'
)
def testHeaderInlineMarkup(self):
""" Test Headers with inline markup. """
text = '#Some *Header* with [markup](http://example.com).'
self.assertEqual(
self.md.convert(text),
''
)
def testAnchorLink(self):
""" Test TOC Anchorlink. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(anchorlink=True)]
)
text = '# Header 1\n\n## Header *2*'
self.assertEqual(
md.convert(text),
'\n'
''
)
def testAnchorLinkWithSingleInlineCode(self):
""" Test TOC Anchorlink with single inline code. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(anchorlink=True)]
)
text = '# This is `code`.'
self.assertEqual(
md.convert(text),
' ' # noqa
)
def testAnchorLinkWithDoubleInlineCode(self):
""" Test TOC Anchorlink with double inline code. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(anchorlink=True)]
)
text = '# This is `code` and `this` too.'
self.assertEqual(
md.convert(text),
' ' # noqa
)
def testPermalink(self):
""" Test TOC Permalink. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(permalink=True)]
)
text = '# Header'
self.assertEqual(
md.convert(text),
'' # noqa
)
def testPermalinkWithSingleInlineCode(self):
""" Test TOC Permalink with single inline code. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(permalink=True)]
)
text = '# This is `code`.'
self.assertEqual(
md.convert(text),
' ' # noqa
'This is code.' # noqa
'' # noqa
'' # noqa
)
def testPermalinkWithDoubleInlineCode(self):
""" Test TOC Permalink with double inline code. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(permalink=True)]
)
text = '# This is `code` and `this` too.'
self.assertEqual(
md.convert(text),
' ' # noqa
'This is code and this too.' # noqa
'' # noqa
'' # noqa
)
def testTitle(self):
""" Test TOC Title. """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(title='Table of Contents')]
)
md.convert('# Header 1\n\n## Header 2')
self.assertStartsWith(
' Table of Contents',
md.toc
)
def testWithAttrList(self):
""" Test TOC with attr_list Extension. """
md = markdown.Markdown(extensions=['toc', 'attr_list'])
text = '# Header 1\n\n## Header 2 { #foo }\n\n## Header 3 { data-toc-label="Foo Bar"}'
self.assertEqual(
md.convert(text),
'\n'
'Header 2\n'
''
)
self.assertEqual(
md.toc,
'\n'
' \n' # noqa
'- Header 1' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' \n' # noqa
' \n' # noqa
'- [TOC]
\n' # noqa
' \n' # noqa
' [TOC]' # noqa
)
text = '#[TOC]\n[TOC]'
self.assertEqual(
self.md.convert(text),
'[TOC]\n' # noqa
'\n' # noqa
' \n' # noqa
'- [TOC]
\n' # noqa
' \n' # noqa
' \n' # noqa
' \n' # noqa
'- [TOC]
\n' # noqa
' \n' # noqa
' [TOC]' # noqa
)
def testMinMaxLevel(self):
""" Test toc_height setting """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(toc_depth='3-4')]
)
text = '# Header 1 not in TOC\n\n## Header 2 not in TOC\n\n### Header 3\n\n####Header 4'
self.assertEqual(
md.convert(text),
'Header 1 not in TOC\n'
'Header 2 not in TOC\n'
'\n'
''
)
self.assertEqual(
md.toc,
'\n'
' \n' # noqa
'- Header 3' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' Header 3 not in TOC'
)
self.assertEqual(
md.toc,
'\n'
' \n' # noqa
'- Header 1' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' First Header\n'
'Second Level\n'
'Third Level'
)
self.assertEqual(
md.toc,
'\n'
)
self.assertNotIn("First Header", md.toc)
def testMaxLevelwithBaseLevel(self):
""" Test toc_depth setting together with baselevel """
md = markdown.Markdown(
extensions=[markdown.extensions.toc.TocExtension(toc_depth=3,
baselevel=2)]
)
text = '# Some Header\n\n## Next Level\n\n### Too High'
self.assertEqual(
md.convert(text),
'\n'
'Next Level\n'
'Too High'
)
self.assertEqual(
md.toc,
'\n'
' \n' # noqa
'- Some Header' # noqa
'\n' # noqa
'
\n' # noqa
' \n' # noqa
' [ The „Unicode char of the year 2014“
is the ‚mdash‘: \u2014
Must not be confused with ‚ndash‘ (\u2013) \u2026 ] """
self.assertEqual(self.md.convert(text), correct)
Markdown-3.1.1/tests/test_legacy.py 0000644 0000765 0000024 00000013146 13446263314 017746 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import LegacyTestCase, Kwargs
import os
import warnings
# Warnings should cause tests to fail...
warnings.simplefilter('error')
# Except for the warnings that shouldn't
warnings.filterwarnings('default', category=PendingDeprecationWarning)
warnings.filterwarnings('default', category=DeprecationWarning, module='markdown')
parent_test_dir = os.path.abspath(os.path.dirname(__file__))
class TestBasic(LegacyTestCase):
location = os.path.join(parent_test_dir, 'basic')
class TestMisc(LegacyTestCase):
location = os.path.join(parent_test_dir, 'misc')
class TestPhp(LegacyTestCase):
"""
Notes on "excluded" tests:
Quotes in attributes: attributes get output in differant order
Inline HTML (Span): Backtick in raw HTML attribute TODO: fixme
Backslash escapes: Weird whitespace issue in output
Ins & del: Our behavior follows markdown.pl I think PHP is wrong here
Auto Links: TODO: fix raw HTML so is doesn't match as a
.
Empty List Item: We match markdown.pl here. Maybe someday we'll support this
Headers: TODO: fix headers to not require blank line before
Mixed OLs and ULs: We match markdown.pl here. I think PHP is wrong here
Emphasis: We have various minor differances in combined & incorrect em markup.
Maybe fix a few of them - but most aren't too important
Code block in a list item: We match markdown.pl - not sure how php gets that output??
PHP-Specific Bugs: Not sure what to make of the escaping stuff here.
Why is PHP not removing a blackslash?
"""
location = os.path.join(parent_test_dir, 'php')
normalize = True
input_ext = '.text'
output_ext = '.xhtml'
exclude = [
'Quotes_in_attributes',
'Inline_HTML_(Span)',
'Backslash_escapes',
'Ins_&_del',
'Auto_Links',
'Empty_List_Item',
'Headers',
'Mixed_OLs_and_ULs',
'Emphasis',
'Code_block_in_a_list_item',
'PHP_Specific_Bugs'
]
# class TestPhpExtra(LegacyTestCase):
# location = os.path.join(parent_test_dir, 'php/extra')
# normalize = True
# input_ext = '.text'
# output_ext = '.xhtml'
# default_kwargs = Kwargs(extensions=['extra'])
class TestPl2004(LegacyTestCase):
location = os.path.join(parent_test_dir, 'pl/Tests_2004')
normalize = True
input_ext = '.text'
exclude = ['Yuri_Footnotes', 'Yuri_Attributes']
class TestPl2007(LegacyTestCase):
"""
Notes on "excluded" tests:
Images: the attributes don't get ordered the same so we skip this
Code Blocks: some weird whitespace issue
Links, reference style: weird issue with nested brackets TODO: fixme
Backslash escapes: backticks in raw html attributes TODO: fixme
Code Spans: more backticks in raw html attributes TODO: fixme
"""
location = os.path.join(parent_test_dir, 'pl/Tests_2007')
normalize = True
input_ext = '.text'
exclude = [
'Images',
'Code_Blocks',
'Links,_reference_style',
'Backslash_escapes',
'Code_Spans'
]
class TestExtensions(LegacyTestCase):
location = os.path.join(parent_test_dir, 'extensions')
exclude = ['codehilite']
attr_list = Kwargs(extensions=['attr_list', 'def_list', 'smarty'])
codehilite = Kwargs(extensions=['codehilite'])
toc = Kwargs(extensions=['toc'])
toc_invalid = Kwargs(extensions=['toc'])
toc_out_of_order = Kwargs(extensions=['toc'])
toc_nested = Kwargs(
extensions=['toc'],
extension_configs={'toc': {'permalink': True}}
)
toc_nested2 = Kwargs(
extensions=['toc'],
extension_configs={'toc': {'permalink': "[link]"}}
)
toc_nested_list = Kwargs(extensions=['toc'])
wikilinks = Kwargs(extensions=['wikilinks'])
fenced_code = Kwargs(extensions=['fenced_code'])
github_flavored = Kwargs(extensions=['fenced_code'])
sane_lists = Kwargs(extensions=['sane_lists'])
nl2br_w_attr_list = Kwargs(extensions=['nl2br', 'attr_list'])
admonition = Kwargs(extensions=['admonition'])
smarty = Kwargs(
extensions=['smarty'],
extension_configs={'smarty': {'smart_angled_quotes': True}}
)
class TestExtensionsExtra(LegacyTestCase):
location = os.path.join(parent_test_dir, 'extensions/extra')
default_kwargs = Kwargs(extensions=['extra'])
loose_def_list = Kwargs(extensions=['def_list'])
simple_def_lists = Kwargs(extensions=['def_list'])
abbr = Kwargs(extensions=['abbr'])
footnotes = Kwargs(extensions=['footnotes'])
tables = Kwargs(extensions=['tables'])
tables_and_attr_list = Kwargs(extensions=['tables', 'attr_list'])
extra_config = Kwargs(
extensions=['extra'],
extension_configs={
'extra': {
'footnotes': {
'PLACE_MARKER': '~~~placemarker~~~'
}
}
}
)
Markdown-3.1.1/tests/test_syntax/ 0000755 0000765 0000024 00000000000 13470647777 017471 5 ustar waylan staff 0000000 0000000 Markdown-3.1.1/tests/test_syntax/__init__.py 0000644 0000765 0000024 00000001371 13330711640 021554 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
Markdown-3.1.1/tests/test_syntax/blocks/ 0000755 0000765 0000024 00000000000 13470647777 020746 5 ustar waylan staff 0000000 0000000 Markdown-3.1.1/tests/test_syntax/blocks/__init__.py 0000644 0000765 0000024 00000001371 13330711640 023031 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
Markdown-3.1.1/tests/test_syntax/blocks/test_code_blocks.py 0000644 0000765 0000024 00000004331 13330711640 024577 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import TestCase
class TestCodeBlocks(TestCase):
def test_spaced_codeblock(self):
self.assertMarkdownRenders(
' # A code block.',
self.dedent(
"""
# A code block.
"""
)
)
def test_tabbed_codeblock(self):
self.assertMarkdownRenders(
'\t# A code block.',
self.dedent(
"""
# A code block.
"""
)
)
def test_multiline_codeblock(self):
self.assertMarkdownRenders(
' # Line 1\n # Line 2\n',
self.dedent(
"""
# Line 1
# Line 2
"""
)
)
def test_codeblock_with_blankline(self):
self.assertMarkdownRenders(
' # Line 1\n\n # Line 2\n',
self.dedent(
"""
# Line 1
# Line 2
"""
)
)
def test_codeblock_escape(self):
self.assertMarkdownRenders(
' ',
self.dedent(
"""
<foo & bar>
"""
)
)
Markdown-3.1.1/tests/test_syntax/blocks/test_headers.py 0000644 0000765 0000024 00000044317 13432642364 023764 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
import unittest
from markdown.test_tools import TestCase
class TestSetextHeaders(TestCase):
def test_setext_h1(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is an H1
=============
"""
),
'This is an H1'
)
def test_setext_h2(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is an H2
-------------
"""
),
'This is an H2'
)
def test_setext_h1_mismatched_length(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is an H1
===
"""
),
'This is an H1'
)
def test_setext_h2_mismatched_length(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is an H2
---
"""
),
'This is an H2'
)
def test_setext_h1_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is an H1
=============
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H1
Followed by a Paragraph with no blank line.
"""
)
)
def test_setext_h2_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is an H2
-------------
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H2
Followed by a Paragraph with no blank line.
"""
)
)
# TODO: fix this
# see http://johnmacfarlane.net/babelmark2/?normalize=1&text=Paragraph%0AAn+H1%0A%3D%3D%3D%3D%3D
@unittest.skip('This is broken in Python-Markdown')
def test_p_followed_by_setext_h1(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is a Paragraph.
Followed by an H1 with no blank line.
=====================================
"""
),
self.dedent(
"""
This is a Paragraph.
Followed by an H1 with no blank line.
"""
)
)
# TODO: fix this
# see http://johnmacfarlane.net/babelmark2/?normalize=1&text=Paragraph%0AAn+H2%0A-----
@unittest.skip('This is broken in Python-Markdown')
def test_p_followed_by_setext_h2(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is a Paragraph.
Followed by an H2 with no blank line.
-------------------------------------
"""
),
self.dedent(
"""
This is a Paragraph.
Followed by an H2 with no blank line.
"""
)
)
class TestHashHeaders(TestCase):
def test_hash_h1_open(self):
self.assertMarkdownRenders(
'# This is an H1',
'This is an H1'
)
def test_hash_h2_open(self):
self.assertMarkdownRenders(
'## This is an H2',
'This is an H2'
)
def test_hash_h3_open(self):
self.assertMarkdownRenders(
'### This is an H3',
'This is an H3'
)
def test_hash_h4_open(self):
self.assertMarkdownRenders(
'#### This is an H4',
'This is an H4'
)
def test_hash_h5_open(self):
self.assertMarkdownRenders(
'##### This is an H5',
'This is an H5'
)
def test_hash_h6_open(self):
self.assertMarkdownRenders(
'###### This is an H6',
'This is an H6'
)
def test_hash_gt6_open(self):
self.assertMarkdownRenders(
'####### This is an H6',
'# This is an H6'
)
def test_hash_h1_open_missing_space(self):
self.assertMarkdownRenders(
'#This is an H1',
'This is an H1'
)
def test_hash_h2_open_missing_space(self):
self.assertMarkdownRenders(
'##This is an H2',
'This is an H2'
)
def test_hash_h3_open_missing_space(self):
self.assertMarkdownRenders(
'###This is an H3',
'This is an H3'
)
def test_hash_h4_open_missing_space(self):
self.assertMarkdownRenders(
'####This is an H4',
'This is an H4'
)
def test_hash_h5_open_missing_space(self):
self.assertMarkdownRenders(
'#####This is an H5',
'This is an H5'
)
def test_hash_h6_open_missing_space(self):
self.assertMarkdownRenders(
'######This is an H6',
'This is an H6'
)
def test_hash_gt6_open_missing_space(self):
self.assertMarkdownRenders(
'#######This is an H6',
'#This is an H6'
)
def test_hash_h1_closed(self):
self.assertMarkdownRenders(
'# This is an H1 #',
'This is an H1'
)
def test_hash_h2_closed(self):
self.assertMarkdownRenders(
'## This is an H2 ##',
'This is an H2'
)
def test_hash_h3_closed(self):
self.assertMarkdownRenders(
'### This is an H3 ###',
'This is an H3'
)
def test_hash_h4_closed(self):
self.assertMarkdownRenders(
'#### This is an H4 ####',
'This is an H4'
)
def test_hash_h5_closed(self):
self.assertMarkdownRenders(
'##### This is an H5 #####',
'This is an H5'
)
def test_hash_h6_closed(self):
self.assertMarkdownRenders(
'###### This is an H6 ######',
'This is an H6'
)
def test_hash_gt6_closed(self):
self.assertMarkdownRenders(
'####### This is an H6 #######',
'# This is an H6'
)
def test_hash_h1_closed_missing_space(self):
self.assertMarkdownRenders(
'#This is an H1#',
'This is an H1'
)
def test_hash_h2_closed_missing_space(self):
self.assertMarkdownRenders(
'##This is an H2##',
'This is an H2'
)
def test_hash_h3_closed_missing_space(self):
self.assertMarkdownRenders(
'###This is an H3###',
'This is an H3'
)
def test_hash_h4_closed_missing_space(self):
self.assertMarkdownRenders(
'####This is an H4####',
'This is an H4'
)
def test_hash_h5_closed_missing_space(self):
self.assertMarkdownRenders(
'#####This is an H5#####',
'This is an H5'
)
def test_hash_h6_closed_missing_space(self):
self.assertMarkdownRenders(
'######This is an H6######',
'This is an H6'
)
def test_hash_gt6_closed_missing_space(self):
self.assertMarkdownRenders(
'#######This is an H6#######',
'#This is an H6'
)
def test_hash_h1_closed_mismatch(self):
self.assertMarkdownRenders(
'# This is an H1 ##',
'This is an H1'
)
def test_hash_h2_closed_mismatch(self):
self.assertMarkdownRenders(
'## This is an H2 #',
'This is an H2'
)
def test_hash_h3_closed_mismatch(self):
self.assertMarkdownRenders(
'### This is an H3 #',
'This is an H3'
)
def test_hash_h4_closed_mismatch(self):
self.assertMarkdownRenders(
'#### This is an H4 #',
'This is an H4'
)
def test_hash_h5_closed_mismatch(self):
self.assertMarkdownRenders(
'##### This is an H5 #',
'This is an H5'
)
def test_hash_h6_closed_mismatch(self):
self.assertMarkdownRenders(
'###### This is an H6 #',
'This is an H6'
)
def test_hash_gt6_closed_mismatch(self):
self.assertMarkdownRenders(
'####### This is an H6 ##################',
'# This is an H6'
)
def test_hash_h1_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
# This is an H1
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H1
Followed by a Paragraph with no blank line.
"""
)
)
def test_hash_h2_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
## This is an H2
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H2
Followed by a Paragraph with no blank line.
"""
)
)
def test_hash_h3_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
### This is an H3
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H3
Followed by a Paragraph with no blank line.
"""
)
)
def test_hash_h4_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
#### This is an H4
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H4
Followed by a Paragraph with no blank line.
"""
)
)
def test_hash_h5_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
##### This is an H5
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H5
Followed by a Paragraph with no blank line.
"""
)
)
def test_hash_h6_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
###### This is an H6
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H6
Followed by a Paragraph with no blank line.
"""
)
)
def test_hash_h1_leading_space(self):
self.assertMarkdownRenders(
' # This is an H1',
'# This is an H1 '
)
def test_hash_h2_leading_space(self):
self.assertMarkdownRenders(
' ## This is an H2',
'## This is an H2 '
)
def test_hash_h3_leading_space(self):
self.assertMarkdownRenders(
' ### This is an H3',
'### This is an H3 '
)
def test_hash_h4_leading_space(self):
self.assertMarkdownRenders(
' #### This is an H4',
'#### This is an H4 '
)
def test_hash_h5_leading_space(self):
self.assertMarkdownRenders(
' ##### This is an H5',
'##### This is an H5 '
)
def test_hash_h6_leading_space(self):
self.assertMarkdownRenders(
' ###### This is an H6',
'###### This is an H6 '
)
def test_hash_h1_open_trailing_space(self):
self.assertMarkdownRenders(
'# This is an H1 ',
'This is an H1'
)
def test_hash_h2_open_trailing_space(self):
self.assertMarkdownRenders(
'## This is an H2 ',
'This is an H2'
)
def test_hash_h3_open_trailing_space(self):
self.assertMarkdownRenders(
'### This is an H3 ',
'This is an H3'
)
def test_hash_h4_open_trailing_space(self):
self.assertMarkdownRenders(
'#### This is an H4 ',
'This is an H4'
)
def test_hash_h5_open_trailing_space(self):
self.assertMarkdownRenders(
'##### This is an H5 ',
'This is an H5'
)
def test_hash_h6_open_trailing_space(self):
self.assertMarkdownRenders(
'###### This is an H6 ',
'This is an H6'
)
def test_hash_gt6_open_trailing_space(self):
self.assertMarkdownRenders(
'####### This is an H6 ',
'# This is an H6'
)
# TODO: Possibly change the following behavior. While this follows the behavior
# of markdown.pl, it is rather uncommon and not nessecarily intuitive.
# See: http://johnmacfarlane.net/babelmark2/?normalize=1&text=%23+This+is+an+H1+%23+
def test_hash_h1_closed_trailing_space(self):
self.assertMarkdownRenders(
'# This is an H1 # ',
'This is an H1 #'
)
def test_hash_h2_closed_trailing_space(self):
self.assertMarkdownRenders(
'## This is an H2 ## ',
'This is an H2 ##'
)
def test_hash_h3_closed_trailing_space(self):
self.assertMarkdownRenders(
'### This is an H3 ### ',
'This is an H3 ###'
)
def test_hash_h4_closed_trailing_space(self):
self.assertMarkdownRenders(
'#### This is an H4 #### ',
'This is an H4 ####'
)
def test_hash_h5_closed_trailing_space(self):
self.assertMarkdownRenders(
'##### This is an H5 ##### ',
'This is an H5 #####'
)
def test_hash_h6_closed_trailing_space(self):
self.assertMarkdownRenders(
'###### This is an H6 ###### ',
'This is an H6 ######'
)
def test_hash_gt6_closed_trailing_space(self):
self.assertMarkdownRenders(
'####### This is an H6 ####### ',
'# This is an H6 #######'
)
def test_no_blank_lines_between_hashs(self):
self.assertMarkdownRenders(
self.dedent(
"""
# This is an H1
## This is an H2
"""
),
self.dedent(
"""
This is an H1
This is an H2
"""
)
)
def test_random_hash_levels(self):
self.assertMarkdownRenders(
self.dedent(
"""
### H3
###### H6
# H1
##### H5
#### H4
## H2
### H3
"""
),
self.dedent(
"""
H3
H6
H1
H5
H4
H2
H3
"""
)
)
def test_hash_followed_by_p(self):
self.assertMarkdownRenders(
self.dedent(
"""
# This is an H1
Followed by a Paragraph with no blank line.
"""
),
self.dedent(
"""
This is an H1
Followed by a Paragraph with no blank line.
"""
)
)
def test_p_followed_by_hash(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is a Paragraph.
# Followed by an H1 with no blank line.
"""
),
self.dedent(
"""
This is a Paragraph.
Followed by an H1 with no blank line.
"""
)
)
def test_escaped_hash(self):
self.assertMarkdownRenders(
"### H3 \\###",
self.dedent(
"""
H3 #
"""
)
)
def test_unescaped_hash(self):
self.assertMarkdownRenders(
"### H3 \\\\###",
self.dedent(
"""
H3 \\
"""
)
)
Markdown-3.1.1/tests/test_syntax/blocks/test_hr.py 0000644 0000765 0000024 00000016710 13330711640 022745 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import TestCase
class TestHorizontalRules(TestCase):
def test_hr_asterisks(self):
self.assertMarkdownRenders(
'***',
'
'
)
def test_hr_asterisks_spaces(self):
self.assertMarkdownRenders(
'* * *',
'
'
)
def test_hr_asterisks_long(self):
self.assertMarkdownRenders(
'*******',
'
'
)
def test_hr_asterisks_spaces_long(self):
self.assertMarkdownRenders(
'* * * * * * *',
'
'
)
def test_hr_asterisks_1_indent(self):
self.assertMarkdownRenders(
' ***',
'
'
)
def test_hr_asterisks_spaces_1_indent(self):
self.assertMarkdownRenders(
' * * *',
'
'
)
def test_hr_asterisks_2_indent(self):
self.assertMarkdownRenders(
' ***',
'
'
)
def test_hr_asterisks_spaces_2_indent(self):
self.assertMarkdownRenders(
' * * *',
'
'
)
def test_hr_asterisks_3_indent(self):
self.assertMarkdownRenders(
' ***',
'
'
)
def test_hr_asterisks_spaces_3_indent(self):
self.assertMarkdownRenders(
' * * *',
'
'
)
def test_hr_asterisks_trailing_space(self):
self.assertMarkdownRenders(
'*** ',
'
'
)
def test_hr_asterisks_spaces_trailing_space(self):
self.assertMarkdownRenders(
'* * * ',
'
'
)
def test_hr_hyphens(self):
self.assertMarkdownRenders(
'---',
'
'
)
def test_hr_hyphens_spaces(self):
self.assertMarkdownRenders(
'- - -',
'
'
)
def test_hr_hyphens_long(self):
self.assertMarkdownRenders(
'-------',
'
'
)
def test_hr_hyphens_spaces_long(self):
self.assertMarkdownRenders(
'- - - - - - -',
'
'
)
def test_hr_hyphens_1_indent(self):
self.assertMarkdownRenders(
' ---',
'
'
)
def test_hr_hyphens_spaces_1_indent(self):
self.assertMarkdownRenders(
' - - -',
'
'
)
def test_hr_hyphens_2_indent(self):
self.assertMarkdownRenders(
' ---',
'
'
)
def test_hr_hyphens_spaces_2_indent(self):
self.assertMarkdownRenders(
' - - -',
'
'
)
def test_hr_hyphens_3_indent(self):
self.assertMarkdownRenders(
' ---',
'
'
)
def test_hr_hyphens_spaces_3_indent(self):
self.assertMarkdownRenders(
' - - -',
'
'
)
def test_hr_hyphens_trailing_space(self):
self.assertMarkdownRenders(
'--- ',
'
'
)
def test_hr_hyphens_spaces_trailing_space(self):
self.assertMarkdownRenders(
'- - - ',
'
'
)
def test_hr_underscores(self):
self.assertMarkdownRenders(
'___',
'
'
)
def test_hr_underscores_spaces(self):
self.assertMarkdownRenders(
'_ _ _',
'
'
)
def test_hr_underscores_long(self):
self.assertMarkdownRenders(
'_______',
'
'
)
def test_hr_underscores_spaces_long(self):
self.assertMarkdownRenders(
'_ _ _ _ _ _ _',
'
'
)
def test_hr_underscores_1_indent(self):
self.assertMarkdownRenders(
' ___',
'
'
)
def test_hr_underscores_spaces_1_indent(self):
self.assertMarkdownRenders(
' _ _ _',
'
'
)
def test_hr_underscores_2_indent(self):
self.assertMarkdownRenders(
' ___',
'
'
)
def test_hr_underscores_spaces_2_indent(self):
self.assertMarkdownRenders(
' _ _ _',
'
'
)
def test_hr_underscores_3_indent(self):
self.assertMarkdownRenders(
' ___',
'
'
)
def test_hr_underscores_spaces_3_indent(self):
self.assertMarkdownRenders(
' _ _ _',
'
'
)
def test_hr_underscores_trailing_space(self):
self.assertMarkdownRenders(
'___ ',
'
'
)
def test_hr_underscores_spaces_trailing_space(self):
self.assertMarkdownRenders(
'_ _ _ ',
'
'
)
def test_hr_before_paragraph(self):
self.assertMarkdownRenders(
self.dedent(
"""
***
An HR followed by a paragraph with no blank line.
"""
),
self.dedent(
"""
An HR followed by a paragraph with no blank line.
"""
)
)
def test_hr_after_paragraph(self):
self.assertMarkdownRenders(
self.dedent(
"""
A paragraph followed by an HR with no blank line.
***
"""
),
self.dedent(
"""
A paragraph followed by an HR with no blank line.
"""
)
)
def test_not_hr_2_asterisks(self):
self.assertMarkdownRenders(
'**',
'** '
)
def test_not_hr_2_asterisks_spaces(self):
self.assertMarkdownRenders(
'* *',
self.dedent(
"""
"""
)
)
def test_not_hr_2_hyphens(self):
self.assertMarkdownRenders(
'--',
'-- '
)
def test_not_hr_2_hyphens_spaces(self):
self.assertMarkdownRenders(
'- -',
self.dedent(
"""
"""
)
)
def test_not_hr_2_underscores(self):
self.assertMarkdownRenders(
'__',
'__ '
)
def test_not_hr_2_underscores_spaces(self):
self.assertMarkdownRenders(
'_ _',
'_ _ '
)
Markdown-3.1.1/tests/test_syntax/blocks/test_paragraphs.py 0000644 0000765 0000024 00000016270 13330711640 024465 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import TestCase
class TestParagraphBlocks(TestCase):
def test_simple_paragraph(self):
self.assertMarkdownRenders(
'A simple paragraph.',
'A simple paragraph. '
)
def test_blank_line_before_paragraph(self):
self.assertMarkdownRenders(
'\nA paragraph preceded by a blank line.',
'A paragraph preceded by a blank line. '
)
def test_multiline_paragraph(self):
self.assertMarkdownRenders(
self.dedent(
"""
This is a paragraph
on multiple lines
with hard returns.
"""
),
self.dedent(
"""
This is a paragraph
on multiple lines
with hard returns.
"""
)
)
def test_paragraph_long_line(self):
self.assertMarkdownRenders(
'A very long long long long long long long long long long long long long long long long long long long '
'long long long long long long long long long long long long long paragraph on 1 line.',
'A very long long long long long long long long long long long long long long long long long long '
'long long long long long long long long long long long long long long paragraph on 1 line. '
)
def test_2_paragraphs_long_line(self):
self.assertMarkdownRenders(
'A very long long long long long long long long long long long long long long long long long long long '
'long long long long long long long long long long long long long paragraph on 1 line.\n\n'
'A new long long long long long long long long long long long long long long long '
'long paragraph on 1 line.',
'A very long long long long long long long long long long long long long long long long long long '
'long long long long long long long long long long long long long long paragraph on 1 line. \n'
'A new long long long long long long long long long long long long long long long '
'long paragraph on 1 line. '
)
def test_consecutive_paragraphs(self):
self.assertMarkdownRenders(
self.dedent(
"""
Paragraph 1.
Paragraph 2.
"""
),
self.dedent(
"""
Paragraph 1.
Paragraph 2.
"""
)
)
def test_consecutive_paragraphs_tab(self):
self.assertMarkdownRenders(
self.dedent(
"""
Paragraph followed by a line with a tab only.
\t
Paragraph after a line with a tab only.
"""
),
self.dedent(
"""
Paragraph followed by a line with a tab only.
Paragraph after a line with a tab only.
"""
)
)
def test_consecutive_paragraphs_space(self):
self.assertMarkdownRenders(
self.dedent(
"""
Paragraph followed by a line with a space only.
Paragraph after a line with a space only.
"""
),
self.dedent(
"""
Paragraph followed by a line with a space only.
Paragraph after a line with a space only.
"""
)
)
def test_consecutive_multiline_paragraphs(self):
self.assertMarkdownRenders(
self.dedent(
"""
Paragraph 1, line 1.
Paragraph 1, line 2.
Paragraph 2, line 1.
Paragraph 2, line 2.
"""
),
self.dedent(
"""
Paragraph 1, line 1.
Paragraph 1, line 2.
Paragraph 2, line 1.
Paragraph 2, line 2.
"""
)
)
def test_paragraph_leading_space(self):
self.assertMarkdownRenders(
' A paragraph with 1 leading space.',
'A paragraph with 1 leading space. '
)
def test_paragraph_2_leading_spaces(self):
self.assertMarkdownRenders(
' A paragraph with 2 leading spaces.',
'A paragraph with 2 leading spaces. '
)
def test_paragraph_3_leading_spaces(self):
self.assertMarkdownRenders(
' A paragraph with 3 leading spaces.',
'A paragraph with 3 leading spaces. '
)
def test_paragraph_trailing_leading_space(self):
self.assertMarkdownRenders(
' A paragraph with 1 trailing and 1 leading space. ',
'A paragraph with 1 trailing and 1 leading space. '
)
def test_paragraph_trailing_tab(self):
self.assertMarkdownRenders(
'A paragraph with 1 trailing tab.\t',
'A paragraph with 1 trailing tab. '
)
def test_paragraphs_CR(self):
self.assertMarkdownRenders(
'Paragraph 1, line 1.\rParagraph 1, line 2.\r\rParagraph 2, line 1.\rParagraph 2, line 2.\r',
self.dedent(
"""
Paragraph 1, line 1.
Paragraph 1, line 2.
Paragraph 2, line 1.
Paragraph 2, line 2.
"""
)
)
def test_paragraphs_LF(self):
self.assertMarkdownRenders(
'Paragraph 1, line 1.\nParagraph 1, line 2.\n\nParagraph 2, line 1.\nParagraph 2, line 2.\n',
self.dedent(
"""
Paragraph 1, line 1.
Paragraph 1, line 2.
Paragraph 2, line 1.
Paragraph 2, line 2.
"""
)
)
def test_paragraphs_CR_LF(self):
self.assertMarkdownRenders(
'Paragraph 1, line 1.\r\nParagraph 1, line 2.\r\n\r\nParagraph 2, line 1.\r\nParagraph 2, line 2.\r\n',
self.dedent(
"""
Paragraph 1, line 1.
Paragraph 1, line 2.
Paragraph 2, line 1.
Paragraph 2, line 2.
"""
)
)
Markdown-3.1.1/tests/test_syntax/extensions/ 0000755 0000765 0000024 00000000000 13470647777 021670 5 ustar waylan staff 0000000 0000000 Markdown-3.1.1/tests/test_syntax/extensions/__init__.py 0000644 0000765 0000024 00000001371 13330711640 023753 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
Markdown-3.1.1/tests/test_syntax/extensions/test_fenced_code.py 0000644 0000765 0000024 00000002720 13432642377 025505 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from __future__ import unicode_literals
from markdown.test_tools import TestCase
class TestFencedCode(TestCase):
# TODO: Move the rest of the fenced code tests here.
def test_fenced_code_in_raw_html(self):
self.assertMarkdownRenders(
self.dedent(
"""
```
Begone placeholders!
```
"""
),
self.dedent(
"""
Begone placeholders!
"""
),
extensions=['fenced_code']
)
Markdown-3.1.1/tests/test_syntax/extensions/test_footnotes.py 0000644 0000765 0000024 00000004400 13432642364 025300 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from __future__ import unicode_literals
from markdown.test_tools import TestCase
class TestFootnotes(TestCase):
def test_backlink_text(self):
"""Test backlink configuration."""
self.assertMarkdownRenders(
'paragraph[^1]\n\n[^1]: A Footnote',
'paragraph \n'
'',
extensions=['footnotes'],
extension_configs={'footnotes': {'BACKLINK_TEXT': 'back'}}
)
def test_footnote_separator(self):
"""Test separator configuration."""
self.assertMarkdownRenders(
'paragraph[^1]\n\n[^1]: A Footnote',
'paragraph \n'
'',
extensions=['footnotes'],
extension_configs={'footnotes': {'SEPARATOR': '-'}}
)
Markdown-3.1.1/tests/test_syntax/extensions/test_legacy_attrs.py 0000644 0000765 0000024 00000004555 13330711640 025743 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from __future__ import unicode_literals
from markdown.test_tools import TestCase
class TestLegacyAtrributes(TestCase):
maxDiff = None
def testLegacyAttrs(self):
self.assertMarkdownRenders(
self.dedent("""
# Header {@id=inthebeginning}
Now, let's try something *inline{@class=special}*, to see if it works
@id=TABLE.OF.CONTENTS}
* {@id=TABLEOFCONTENTS}
Or in the middle of the text {@id=TABLEOFCONTENTS}
{@id=tableofcontents}
[](http://fourthought.com/)
![img{@id=foo}][img]
[img]: http://example.com/i.jpg
"""),
self.dedent("""
Header
Now, let's try something inline, to see if it works
@id=TABLE.OF.CONTENTS}
Or in the middle of the text
"""), # noqa: E501
extensions=['legacy_attrs']
)
Markdown-3.1.1/tests/test_syntax/extensions/test_legacy_em.py 0000644 0000765 0000024 00000002404 13432642364 025207 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from __future__ import unicode_literals
from markdown.test_tools import TestCase
class TestLegacyEm(TestCase):
def test_legacy_emphasis(self):
self.assertMarkdownRenders(
'_connected_words_',
'connectedwords_ ',
extensions=['legacy_em']
)
def test_legacy_strong(self):
self.assertMarkdownRenders(
'__connected__words__',
'connectedwords__ ',
extensions=['legacy_em']
)
Markdown-3.1.1/tests/test_syntax/extensions/test_tables.py 0000644 0000765 0000024 00000003257 13330711640 024532 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from __future__ import unicode_literals
from markdown.test_tools import TestCase
class TestTableBlocks(TestCase):
def test_empty_cells(self):
"""Empty cells (nbsp)."""
text = """
| Second Header
------------- | -------------
| Content Cell
Content Cell |
"""
self.assertMarkdownRenders(
text,
self.dedent(
"""
| |
Second Header |
| |
Content Cell |
| Content Cell |
|
"""
),
extensions=['tables']
)
Markdown-3.1.1/tests/test_syntax/inline/ 0000755 0000765 0000024 00000000000 13470647777 020747 5 ustar waylan staff 0000000 0000000 Markdown-3.1.1/tests/test_syntax/inline/__init__.py 0000644 0000765 0000024 00000001371 13330711640 023032 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
Markdown-3.1.1/tests/test_syntax/inline/test_emphasis.py 0000644 0000765 0000024 00000004524 13432642377 024163 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2019 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import TestCase
class TestNotEmphasis(TestCase):
def test_standalone_asterisk(self):
self.assertMarkdownRenders(
'*',
'* '
)
def test_standalone_understore(self):
self.assertMarkdownRenders(
'_',
'_ '
)
def test_standalone_asterisk_in_text(self):
self.assertMarkdownRenders(
'foo * bar',
'foo * bar '
)
def test_standalone_understore_in_text(self):
self.assertMarkdownRenders(
'foo _ bar',
'foo _ bar '
)
def test_standalone_asterisks_in_text(self):
self.assertMarkdownRenders(
'foo * bar * baz',
'foo * bar * baz '
)
def test_standalone_understores_in_text(self):
self.assertMarkdownRenders(
'foo _ bar _ baz',
'foo _ bar _ baz '
)
def test_standalone_asterisks_with_newlines(self):
self.assertMarkdownRenders(
'foo\n* bar *\nbaz',
'foo\n* bar *\nbaz '
)
def test_standalone_understores_with_newlines(self):
self.assertMarkdownRenders(
'foo\n_ bar _\nbaz',
'foo\n_ bar _\nbaz '
)
def test_standalone_asterisks_at_end(self):
self.assertMarkdownRenders(
'foo * bar *',
'foo * bar * '
)
def test_standalone_understores_at_begin_end(self):
self.assertMarkdownRenders(
'_ bar _',
'_ bar _ '
)
Markdown-3.1.1/tests/test_syntax/inline/test_entities.py 0000644 0000765 0000024 00000003161 13432642364 024166 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import TestCase
class TestEntities(TestCase):
def test_named_entities(self):
self.assertMarkdownRenders("&", "& ")
self.assertMarkdownRenders("²", "² ")
self.assertMarkdownRenders("Á", "Á ")
def test_decimal_entities(self):
self.assertMarkdownRenders("&", "& ")
self.assertMarkdownRenders("²", "² ")
def test_hexadecimal_entities(self):
self.assertMarkdownRenders("&", "& ")
self.assertMarkdownRenders("²", "² ")
def test_false_entities(self):
self.assertMarkdownRenders("¬ an entity;", "¬ an entity; ")
self.assertMarkdownRenders("&#B2;", "&#B2; ")
self.assertMarkdownRenders("&#xnothex;", "&#xnothex; ")
Markdown-3.1.1/tests/test_syntax/inline/test_images.py 0000644 0000765 0000024 00000014342 13424435527 023614 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import TestCase
class TestAdvancedImages(TestCase):
def test_nested_square_brackets(self):
self.assertMarkdownRenders(
"""![Text[[[[[[[]]]]]]][]](http://link.com/image.png) more text""",
"""![Text[[[[[[[]]]]]]][]](http://link.com/image.png) more text
"""
)
def test_nested_round_brackets(self):
self.assertMarkdownRenders(
"""))))))()).png) more text""",
"""))))))()).png) more text
"""
)
def test_uneven_brackets_with_titles1(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/(.png"title") more text""",
""" more text
"""
)
def test_uneven_brackets_with_titles2(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/('.png"title") more text""",
""" more text
"""
)
def test_uneven_brackets_with_titles3(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/(.png"title)") more text""",
""" more text """
)
def test_uneven_brackets_with_titles4(self):
self.assertMarkdownRenders(
""" more text""",
""" more text """
)
def test_uneven_brackets_with_titles5(self):
self.assertMarkdownRenders(
""" more text""",
""" more text """
)
def test_mixed_title_quotes1(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/'.png"title") more text""",
""" more text
"""
)
def test_mixed_title_quotes2(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/".png'title') more text""",
"""![Text](http://link.com/".png "title") more text
"""
)
def test_mixed_title_quotes3(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/with spaces.png'"and quotes" 'and title') more text""",
""" """
""" more text
"""
)
def test_mixed_title_quotes4(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/with spaces'.png"and quotes" 'and title") more text""",
""" """
""" more text
"""
)
def test_mixed_title_quotes5(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/with spaces .png'"and quotes" 'and title') more text""",
""" more text
"""
)
def test_mixed_title_quotes6(self):
self.assertMarkdownRenders(
"""![Text](http://link.com/with spaces "and quotes".png 'and title') more text""",
"""![Text](http://link.com/with spaces "and quotes".png "and title") """
""" more text
"""
)
def test_single_quote(self):
self.assertMarkdownRenders(
"""![test](link"notitle.png)""",
"""![test](link"notitle.png)
"""
)
def test_angle_with_mixed_title_quotes(self):
self.assertMarkdownRenders(
""" more text""",
"""![Text](http://link.com/with spaces '"and quotes".png "and title") """
""" more text
"""
)
def test_misc(self):
self.assertMarkdownRenders(
"""""",
"""
"""
)
def test_misc_ref(self):
self.assertMarkdownRenders(
self.dedent(
"""
![Poster][]
[Poster]:http://humane_man.jpg "The most humane man."
"""
),
self.dedent(
"""
"""
)
)
def test_misc_blank(self):
self.assertMarkdownRenders(
"""![Blank]()""",
"""![Blank]()
"""
)
def test_misc_img_title(self):
self.assertMarkdownRenders(
"""""",
"""
"""
)
def test_misc_img(self):
self.assertMarkdownRenders(
"""""",
"""
"""
)
Markdown-3.1.1/tests/test_syntax/inline/test_links.py 0000644 0000765 0000024 00000015211 13432642364 023461 0 ustar waylan staff 0000000 0000000 # -*- coding: utf-8 -*-
"""
Python Markdown
A Python implementation of John Gruber's Markdown.
Documentation: https://python-markdown.github.io/
GitHub: https://github.com/Python-Markdown/markdown/
PyPI: https://pypi.org/project/Markdown/
Started by Manfred Stienstra (http://www.dwerg.net/).
Maintained for a few years by Yuri Takhteyev (http://www.freewisdom.org).
Currently maintained by Waylan Limberg (https://github.com/waylan),
Dmitry Shachnev (https://github.com/mitya57) and Isaac Muse (https://github.com/facelessuser).
Copyright 2007-2018 The Python Markdown Project (v. 1.7 and later)
Copyright 2004, 2005, 2006 Yuri Takhteyev (v. 0.2-1.6b)
Copyright 2004 Manfred Stienstra (the original version)
License: BSD (see LICENSE.md for details).
"""
from markdown.test_tools import TestCase
class TestAdvancedLinks(TestCase):
def test_nested_square_brackets(self):
self.assertMarkdownRenders(
"""[Text[[[[[[[]]]]]]][]](http://link.com) more text""",
"""Text[[[[[[[]]]]]]][] more text """
)
def test_nested_round_brackets(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/(((((((()))))))())) more text""",
"""Text more text """
)
def test_uneven_brackets_with_titles1(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/("title") more text""",
"""Text more text """
)
def test_uneven_brackets_with_titles2(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/('"title") more text""",
"""Text more text """
)
def test_uneven_brackets_with_titles3(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/("title)") more text""",
"""Text more text """
)
def test_uneven_brackets_with_titles4(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/( "title") more text""",
"""Text more text """
)
def test_uneven_brackets_with_titles5(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/( "title)") more text""",
"""Text more text """
)
def test_mixed_title_quotes1(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/'"title") more text""",
"""Text more text """
)
def test_mixed_title_quotes2(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/"'title') more text""",
"""Text more text """
)
def test_mixed_title_quotes3(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/with spaces'"and quotes" 'and title') more text""",
""""""
"""Text more text """
)
def test_mixed_title_quotes4(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/with spaces'"and quotes" 'and title") more text""",
"""Text more text """
)
def test_mixed_title_quotes5(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/with spaces '"and quotes" 'and title') more text""",
""""""
"""Text more text """
)
def test_mixed_title_quotes6(self):
self.assertMarkdownRenders(
"""[Text](http://link.com/with spaces "and quotes" 'and title') more text""",
""""""
"""Text more text """
)
def test_single_quote(self):
self.assertMarkdownRenders(
"""[test](link"notitle)""",
"""test """
)
def test_angle_with_mixed_title_quotes(self):
self.assertMarkdownRenders(
"""[Text]( 'and title') more text""",
""""""
"""Text more text """
)
def test_amp_in_url(self):
"""Test amp in URLs."""
self.assertMarkdownRenders(
'[link](http://www.freewisdom.org/this&that)',
'link '
)
self.assertMarkdownRenders(
'[title](http://example.com/?a=1&b=2)',
'title '
)
self.assertMarkdownRenders(
'[title](http://example.com/?a=1&b=2)',
'title '
)
def test_reference_newlines(self):
"""Test reference id whitespace cleanup."""
self.assertMarkdownRenders(
self.dedent(
"""
Two things:
- I would like to tell you about the [code of
conduct][] we are using in this project.
- Only one in fact.
[code of conduct]: https://github.com/Python-Markdown/markdown/blob/master/CODE_OF_CONDUCT.md
"""
),
'Two things: \n\n- I would like to tell you about the '
'code of\n'
' conduct we are using in this project.
\n- Only one in fact.
\n '
)
def test_reference_across_blocks(self):
"""Test references across blocks."""
self.assertMarkdownRenders(
self.dedent(
"""
I would like to tell you about the [code of
conduct][] we are using in this project.
[code of conduct]: https://github.com/Python-Markdown/markdown/blob/master/CODE_OF_CONDUCT.md
"""
),
'I would like to tell you about the [code of \n'
'conduct][] we are using in this project. '
)
Markdown-3.1.1/tox.ini 0000644 0000765 0000024 00000001221 13470641027 015227 0 ustar waylan staff 0000000 0000000 [tox]
envlist = py27, py35, py36, py37, pypy, pypy3, flake8, checkspelling, pep517check
requires = setuptools>=36
isolated_build = True
[testenv]
extras = testing
deps = pytidylib
commands = coverage run --source=markdown -m unittest discover {toxinidir}/tests
coverage report --show-missing
[testenv:flake8]
deps = flake8
commands = flake8 {toxinidir}/markdown {toxinidir}/tests {toxinidir}/setup.py
[testenv:checkspelling]
deps =
mkdocs
mkdocs_nature
commands = {toxinidir}/checkspelling.sh
[testenv:pep517check]
deps = pep517
commands = python -m pep517.check {toxinidir}
[flake8]
max-line-length = 119
exclude=markdown/pep562.py
|
|
