The primary documentation for Markdown Mode is available below, and
is generated from comments in the source code. For a more in-depth
treatment, the [_Guide to Markdown Mode for Emacs_][guide] covers
Markdown syntax, advanced movement and editing in Emacs,
extensions, configuration examples, tips and tricks, and a survey
of other packages that work with Markdown Mode. Finally, Emacs is
also a self-documenting editor. This means that the source code
itself contains additional documentation: each function has its own
docstring available via C-h f (`describe-function`), individual
keybindings can be investigated with C-h k (`describe-key`), and
a complete list of keybindings is available using C-h m
(`describe-mode`).
[guide]: https://leanpub.com/markdown-mode
## Installation
_Note:_ To use all of the features of `markdown-mode`, you'll need
to install the Emacs package itself and also have a local Markdown
processor installed (e.g., Markdown.pl, MultiMarkdown, or Pandoc).
The external processor is not required for editing, but will be
used for rendering HTML for preview and export. After installing
the Emacs package, be sure to configure `markdown-command` to point
to the preferred Markdown executable on your system. See the
Customization section below for more details.
The recommended way to install `markdown-mode` is to install the package
from [MELPA Stable](https://stable.melpa.org/#/markdown-mode)
using `package.el`. First, configure `package.el` and the MELPA Stable
repository by adding the following to your `.emacs`, `init.el`,
or equivalent startup file:
```lisp
(require 'package)
(add-to-list 'package-archives
'("melpa-stable" . "https://stable.melpa.org/packages/"))
(package-initialize)
```
Then, after restarting Emacs or evaluating the above statements, issue
the following command: M-x package-install RET markdown-mode RET.
When installed this way, the major modes `markdown-mode` and `gfm-mode`
will be autoloaded and `markdown-mode` will be used for file names
ending in either `.md` or `.markdown`.
Alternatively, if you manage loading packages with [use-package][]
then you can automatically install and configure `markdown-mode` by
adding a declaration such as this one to your init file (as an
example; adjust settings as desired):
```lisp
(use-package markdown-mode
:ensure t
:mode (("README\\.md\\'" . gfm-mode)
("\\.md\\'" . markdown-mode)
("\\.markdown\\'" . markdown-mode))
:init (setq markdown-command "multimarkdown"))
```
[MELPA Stable]: http://stable.melpa.org/
[use-package]: https://github.com/jwiegley/use-package
**Direct Download**
Alternatively you can manually download and install markdown-mode.
First, download the [latest stable version][markdown-mode.el] and
save the file where Emacs can find it (i.e., a directory in your
`load-path`). You can then configure `markdown-mode` and `gfm-mode`
to load automatically by adding the following to your init file:
```lisp
(autoload 'markdown-mode "markdown-mode"
"Major mode for editing Markdown files" t)
(add-to-list 'auto-mode-alist '("\\.markdown\\'" . markdown-mode))
(add-to-list 'auto-mode-alist '("\\.md\\'" . markdown-mode))
(autoload 'gfm-mode "markdown-mode"
"Major mode for editing GitHub Flavored Markdown files" t)
(add-to-list 'auto-mode-alist '("README\\.md\\'" . gfm-mode))
```
[markdown-mode.el]: https://jblevins.org/projects/markdown-mode/markdown-mode.el
**Development Version**
To follow or contribute to markdown-mode development, you can
browse or clone the Git repository
[on GitHub](https://github.com/jrblevin/markdown-mode):
```
git clone https://github.com/jrblevin/markdown-mode.git
```
If you prefer to install and use the development version, which may
become unstable at some times, you can either clone the Git
repository as above or install markdown-mode from
[MELPA](https://melpa.org/#/markdown-mode).
If you clone the repository directly, then make sure that Emacs can
find it by adding the following line to your startup file:
```lisp
(add-to-list 'load-path "/path/to/markdown-mode/repository")
```
**Packaged Installation**
markdown-mode is also available in several package managers. You
may want to confirm that the package you install contains the
latest stable version first (and please notify the package
maintainer if not).
* Debian Linux: [elpa-markdown-mode][] and [emacs-goodies-el][]
* Ubuntu Linux: [elpa-markdown-mode][elpa-ubuntu] and [emacs-goodies-el][emacs-goodies-el-ubuntu]
* RedHat and Fedora Linux: [emacs-goodies][]
* NetBSD: [textproc/markdown-mode][]
* MacPorts: [markdown-mode.el][macports-package] ([pending][macports-ticket])
* FreeBSD: [textproc/markdown-mode.el][freebsd-port]
[elpa-markdown-mode]: https://packages.debian.org/sid/lisp/elpa-markdown-mode
[elpa-ubuntu]: http://packages.ubuntu.com/search?keywords=elpa-markdown-mode
[emacs-goodies-el]: http://packages.debian.org/emacs-goodies-el
[emacs-goodies-el-ubuntu]: http://packages.ubuntu.com/search?keywords=emacs-goodies-el
[emacs-goodies]: https://apps.fedoraproject.org/packages/emacs-goodies
[textproc/markdown-mode]: http://pkgsrc.se/textproc/markdown-mode
[macports-package]: https://trac.macports.org/browser/trunk/dports/editors/markdown-mode.el/Portfile
[macports-ticket]: http://trac.macports.org/ticket/35716
[freebsd-port]: http://svnweb.freebsd.org/ports/head/textproc/markdown-mode.el
**Dependencies**
To enable editing of code blocks in indirect buffers using C-c ',
you will need to install the [`edit-indirect`][ei] package.
[ei]: https://github.com/Fanael/edit-indirect/
## Usage
Keybindings are grouped by prefixes based on their function. For
example, the commands for styling text are grouped under C-c C-s
and toggle commands begin with C-c C-x. The primary commands in
each group will are described below. You can obtain a list of all
keybindings by pressing C-c C-h. Movement and shifting commands
tend to be associated with paired delimiters such as M-{ and
M-} or C-c < and C-c >. Outline navigation keybindings the
same as in `org-mode`. Finally, commands for running Markdown or
doing maintenance on an open file are grouped under the C-c C-c
prefix. The most commonly used commands are described below. You
can obtain a list of all keybindings by pressing C-c C-h.
* Links and Images: C-c C-l and C-c C-i
C-c C-l (`markdown-insert-link`) is a general command for
inserting new link markup or editing existing link markup. This
is especially useful when markup or URL hiding is enabled, so
that URLs can't easily be edited directly. This command can be
used to insert links of any form: either inline links,
reference links, or plain URLs in angle brackets. The URL or
`[reference]` label, link text, and optional title are entered
through a series of interactive prompts. The type of link is
determined by which values are provided:
* If both a URL and link text are given, insert an inline link:
`[text](url)`.
* If both a `[reference]` label and link text are given, insert
a reference link: `[text][reference]`.
* If only link text is given, insert an implicit reference link:
`[text][]`.
* If only a URL is given, insert a plain URL link:
`` to ``) while "demotion" means *increasing* the
level. For horizontal rules, promotion and demotion means
moving backward or forward through the list of rule strings in
`markdown-hr-strings`. For bold and italic text, promotion and
demotion means changing the markup from underscores to asterisks.
Press C-c C-- or C-c LEFT to promote the element at the point
if possible.
To remember these commands, note that - is for decreasing the
level (promoting), and = (on the same key as +) is for
increasing the level (demoting). Similarly, the left and right
arrow keys indicate the direction that the atx heading markup
is moving in when promoting or demoting.
* Completion: C-c C-]
Complete markup is in normalized form, which means, for
example, that the underline portion of a setext header is the
same length as the heading text, or that the number of leading
and trailing hash marks of an atx header are equal and that
there is no extra whitespace in the header text. C-c C-]
completes the markup at the point, if it is determined to be
incomplete.
* Editing Lists: M-RET, C-c UP, C-c DOWN, C-c LEFT, and C-c RIGHT
New list items can be inserted with M-RET or C-c C-j. This
command determines the appropriate marker (one of the possible
unordered list markers or the next number in sequence for an
ordered list) and indentation level by examining nearby list
items. If there is no list before or after the point, start a
new list. As with heading insertion, you may prefix this
command by C-u to decrease the indentation by one level.
Prefix this command by C-u C-u to increase the indentation by
one level.
Existing list items (and their nested sub-items) can be moved
up or down with C-c UP or C-c DOWN and indented or
outdented with C-c RIGHT or C-c LEFT.
* Editing Subtrees: C-c UP, C-c DOWN, C-c LEFT, and C-c RIGHT
Entire subtrees of ATX headings can be promoted and demoted
with C-c LEFT and C-c RIGHT, which are the same keybindings
used for promotion and demotion of list items. If the point is in
a list item, the operate on the list item. Otherwise, they operate
on the current heading subtree. Similarly, subtrees can be
moved up and down with C-c UP and C-c DOWN.
These commands currently do not work properly if there are
Setext headings in the affected region.
Please note the following "boundary" behavior for promotion and
demotion. Any level-six headings will not be demoted further
(i.e., they remain at level six, since Markdown and HTML define
only six levels) and any level-one headings will promoted away
entirely (i.e., heading markup will be removed, since a
level-zero heading is not defined).
* Shifting the Region: C-c < and C-c >
Text in the region can be indented or outdented as a group using
C-c > to indent to the next indentation point (calculated in
the current context), and C-c < to outdent to the previous
indentation point. These keybindings are the same as those for
similar commands in `python-mode`.
* Killing Elements: C-c C-k
Press C-c C-k to kill the thing at point and add important
text, without markup, to the kill ring. Possible things to
kill include (roughly in order of precedece): inline code,
headings, horizonal rules, links (add link text to kill ring),
images (add alt text to kill ring), angle URIs, email
addresses, bold, italics, reference definitions (add URI to
kill ring), footnote markers and text (kill both marker and
text, add text to kill ring), and list items.
* Outline Navigation: C-c C-n, C-c C-p, C-c C-f, C-c C-b, and C-c C-u
These keys are used for hierarchical navigation in lists and
headings. When the point is in a list, they move between list
items. Otherwise, they move between headings. Use C-c C-n and
C-c C-p to move between the next and previous visible
headings or list items of any level. Similarly, C-c C-f and
C-c C-b move to the next and previous visible headings or
list items at the same level as the one at the point. Finally,
C-c C-u will move up to the parent heading or list item.
* Movement by Markdown paragraph: M-{, M-}, and M-h
Paragraphs in `markdown-mode` are regular paragraphs,
paragraphs inside blockquotes, individual list items, headings,
etc. These keys are usually bound to `forward-paragraph` and
`backward-paragraph`, but the built-in Emacs functions are
based on simple regular expressions that fail in Markdown
files. Instead, they are bound to `markdown-forward-paragraph`
and `markdown-backward-paragraph`. To mark a paragraph,
you can use M-h (`markdown-mark-paragraph`).
* Movement by Markdown block: C-M-{, C-M-}, and C-c M-h
Markdown blocks are regular paragraphs in many cases, but
contain many paragraphs in other cases: blocks are considered
to be entire lists, entire code blocks, and entire blockquotes.
To move backward one block use C-M-{
(`markdown-beginning-block`) and to move forward use C-M-}
(`markdown-end-of-block`). To mark a block, use C-c M-h
(`markdown-mark-block`).
* Movement by Defuns: C-M-a, C-M-e, and C-M-h
The usual Emacs commands can be used to move by defuns
(top-level major definitions). In markdown-mode, a defun is a
section. As usual, C-M-a will move the point to the
beginning of the current or preceding defun, C-M-e will move
to the end of the current or following defun, and C-M-h will
put the region around the entire defun.
* Table Editing:
Markdown Mode includes support for editing tables, which
have the following basic format:
| Right | Left | Center | Default |
|------:|:-----|:------:|---------|
| 12 | 12 | 12 | 12 |
| 123 | 123 | 123 | 123 |
| 1 | 1 | 1 | 1 |
The first line contains column headers. The second line
contains a separator line between the headers and the content.
Each following line is a row in the table. Columns are always
separated by the pipe character. The colons indicate column
alignment.
A table is re-aligned automatically each time you press TAB
or RET inside the table. TAB also moves to the next
field (RET to the next row) and creates new table rows at
the end of the table or before horizontal separator lines. The
indentation of the table is set by the first line. Column
centering inside Emacs is not supported.
Beginning pipe characters are required for proper detection of
table borders inside Emacs. Any line starting with `|-` or `|:`
is considered as a horizontal separator line and will be
expanded on the next re-align to span the whole table width. No
padding is allowed between the beginning pipe character and
header separator symbol. So, to create the above table, you
would only type
|Right|Left|Center|Default|
|-
and then press TAB to align the table and start filling in
cells.
Then you can jump with TAB from one cell to the next or with
S-TAB to the previous one. RET will jump to the to the
next cell in the same column, and create a new row if there is
no such cell or if the next row is beyond a separator line.
You can also convert selected region to a table. Basic editing
capabilities include inserting, deleting, and moving of columns
and rows, and table re-alignment, sorting, transposition:
- C-c UP or C-c DOWN - Move the current row up or down.
- C-c LEFT or C-c RIGHT - Move the current column left or right.
- C-c S-UP - Kill the current row.
- C-c S-DOWN - Insert a row above the current row. With a
prefix argument, row line is created below the current one.
- C-c S-LEFT - Kill the current column.
- C-c S-RIGHT - Insert a new column to the left of the current one.
- C-c C-d - Re-align the current table (`markdown-do`).
- C-c C-c ^ - Sort the rows of a table by a specified column.
This command prompts you for the column number and a sort
method (alphabetical or numerical, optionally in reverse).
- C-c C-c | - Convert the region to a table. This function
attempts to recognize comma, tab, and space separated data
and then splits the data into cells accordingly.
- C-c C-c t - Transpose table at point.
The table editing functions try to handle markup hiding
correctly when calculating column widths, however, columns
containing hidden markup may not always be aligned properly.
* Viewing Modes:
Read-only viewing modes, `markdown-view-mode` and `gfm-view-mode`
are provided for viewing Markdown content. These modes provide
simplified keybindings for navigating the buffer. Many of these
are like `help-mode` and `view-mode`, such as SPC,
DEL, <, and > for scrolling,
q for quitting, and ? or h for
help. Other keys are provided that mirror the outline navigation
commands when editing: n, p, f,
b, and u. Both of these modes enable markup
hiding by default, but this can be customized by setting
`markdown-hide-markup-in-view-modes`.
* Miscellaneous Commands:
When the [`edit-indirect`][ei] package is installed, C-c '
(`markdown-edit-code-block`) can be used to edit a code block
in an indirect buffer in the native major mode. Press C-c C-c
to commit changes and return or C-c C-k to cancel. You can
also give a prefix argument to the insertion command, as in
C-u C-c C-s C, to edit the code block in an indirect buffer
upon insertion.
As noted, many of the commands above behave differently depending
on whether Transient Mark mode is enabled or not. When it makes
sense, if Transient Mark mode is on and the region is active, the
command applies to the text in the region (e.g., C-c C-s b makes the
region bold). For users who prefer to work outside of Transient
Mark mode, since Emacs 22 it can be enabled temporarily by pressing
C-SPC C-SPC. When this is not the case, many commands then
proceed to look work with the word or line at the point.
When applicable, commands that specifically act on the region even
outside of Transient Mark mode have the same keybinding as their
standard counterpart, but the letter is uppercase. For example,
`markdown-insert-blockquote` is bound to C-c C-s q and only acts on
the region in Transient Mark mode while `markdown-blockquote-region`
is bound to C-c C-s Q and always applies to the region (when nonempty).
Note that these region-specific functions are useful in many
cases where it may not be obvious. For example, yanking text from
the kill ring sets the mark at the beginning of the yanked text
and moves the point to the end. Therefore, the (inactive) region
contains the yanked text. So, C-y followed by C-c C-s Q will
yank text and turn it into a blockquote.
markdown-mode attempts to be flexible in how it handles
indentation. When you press TAB repeatedly, the point will cycle
through several possible indentation levels corresponding to things
you might have in mind when you press RET at the end of a line or
TAB. For example, you may want to start a new list item,
continue a list item with hanging indentation, indent for a nested
pre block, and so on. Outdenting is handled similarly when backspace
is pressed at the beginning of the non-whitespace portion of a line.
markdown-mode supports outline-minor-mode as well as org-mode-style
visibility cycling for atx- or hash-style headings. There are two
types of visibility cycling: Pressing S-TAB cycles globally between
the table of contents view (headings only), outline view (top-level
headings only), and the full document view. Pressing TAB while the
point is at a heading will cycle through levels of visibility for the
subtree: completely folded, visible children, and fully visible.
Note that mixing hash and underline style headings will give undesired
results.
## Customization
Although no configuration is *necessary* there are a few things
that can be customized. The M-x customize-mode command
provides an interface to all of the possible customizations:
* `markdown-command` - the command used to run Markdown (default:
`markdown`). This variable may be customized to pass
command-line options to your Markdown processor of choice. It can
also be a function; in this case `markdown` will call it with three
arguments: the beginning and end of the region to process, and
a buffer to write the output to.
* `markdown-command-needs-filename` - set to `t` if
`markdown-command` does not accept standard input (default:
`nil`). When `nil`, `markdown-mode` will pass the Markdown
content to `markdown-command` using standard input (`stdin`).
When set to `t`, `markdown-mode` will pass the name of the file
as the final command-line argument to `markdown-command`. Note
that in the latter case, you will only be able to run
`markdown-command` from buffers which are visiting a file. If
`markdown-command` is a function, `markdown-command-needs-filename`
is ignored.
* `markdown-open-command` - the command used for calling a standalone
Markdown previewer which is capable of opening Markdown source files
directly (default: `nil`). This command will be called
with a single argument, the filename of the current buffer.
A representative program is the Mac app [Marked 2][], a
live-updating Markdown previewer which can be [called from a
simple shell script](https://jblevins.org/log/marked-2-command).
This variable can also be a function; in this case `markdown-open`
will call it without arguments to preview the current buffer.
* `markdown-hr-strings` - list of strings to use when inserting
horizontal rules. Different strings will not be distinguished
when converted to HTML--they will all be converted to
`
`--but they may add visual distinction and style to plain
text documents. To maintain some notion of promotion and
demotion, keep these sorted from largest to smallest.
* `markdown-bold-underscore` - set to a non-nil value to use two
underscores when inserting bold text instead of two asterisks
(default: `nil`).
* `markdown-italic-underscore` - set to a non-nil value to use
underscores when inserting italic text instead of asterisks
(default: `nil`).
* `markdown-asymmetric-header` - set to a non-nil value to use
asymmetric header styling, placing header characters only on
the left of headers (default: `nil`).
* `markdown-header-scaling` - set to a non-nil value to use
a variable-pitch font for headings where the size corresponds
to the level of the heading (default: `nil`).
* `markdown-header-scaling-values` - list of scaling values,
relative to baseline, for headers of levels one through six,
used when `markdown-header-scaling` is non-nil
(default: `(2.0 1.7 1.4 1.1 1.0 1.0)`).
* `markdown-marginalize-headers` - put opening atx header markup
in the left margin when non-nil (default: `nil`).
* `markdown-marginalize-headers-margin-width` - width of margin
used for marginalized headers (default: 6).
* `markdown-list-indent-width` - depth of indentation for lists
when inserting, promoting, and demoting list items (default: 4).
* `markdown-indent-function` - the function to use for automatic
indentation (default: `markdown-indent-line`).
* `markdown-indent-on-enter` - Set to a non-nil value to
automatically indent new lines when RET is pressed.
Set to `indent-and-new-item` to additionally continue lists
when RET is pressed (default: `t`).
* `markdown-enable-wiki-links` - syntax highlighting for wiki
links (default: `nil`). Set this to a non-nil value to turn on
wiki link support by default. Wiki link support can be toggled
later using the function `markdown-toggle-wiki-links`."
* `markdown-wiki-link-alias-first` - set to a non-nil value to
treat aliased wiki links like `[[link text|PageName]]`
(default: `t`). When set to nil, they will be treated as
`[[PageName|link text]]`.
* `markdown-uri-types` - a list of protocol schemes (e.g., "http")
for URIs that `markdown-mode` should highlight.
* `markdown-enable-math` - font lock for inline and display LaTeX
math expressions (default: `nil`). Set this to `t` to turn on
math support by default. Math support can be toggled
interactively later using C-c C-x C-e
(`markdown-toggle-math`).
* `markdown-enable-html` - font lock for HTML tags and attributes
(default: `t`).
* `markdown-css-paths` - CSS files to link to in XHTML output
(default: `nil`).
* `markdown-content-type` - when set to a nonempty string, an
`http-equiv` attribute will be included in the XHTML ``
block (default: `""`). If needed, the suggested values are
`application/xhtml+xml` or `text/html`. See also:
`markdown-coding-system`.
* `markdown-coding-system` - used for specifying the character
set identifier in the `http-equiv` attribute when included
(default: `nil`). See `markdown-content-type`, which must
be set before this variable has any effect. When set to `nil`,
`buffer-file-coding-system` will be used to automatically
determine the coding system string (falling back to
`iso-8859-1` when unavailable). Common settings are `utf-8`
and `iso-latin-1`.
* `markdown-xhtml-header-content` - additional content to include
in the XHTML `` block (default: `""`).
* `markdown-xhtml-standalone-regexp` - a regular expression which
`markdown-mode` uses to determine whether the output of
`markdown-command` is a standalone XHTML document or an XHTML
fragment (default: `"^\\(<\\?xml\\|C-c C-x C-l
(`markdown-toggle-url-hiding`)
or from the Markdown | Links & Images menu.
* `markdown-hide-markup` - Determines whether all possible markup
is hidden or otherwise beautified (default: `nil`). The actual
buffer text remains unchanged, but the display will be altered.
Brackets and URLs for links will be hidden, asterisks and
underscores for italic and bold text will be hidden, text
bullets for unordered lists will be replaced by Unicode
bullets, and so on. Since this includes URLs and reference
labels, when non-nil this setting supersedes `markdown-hide-urls`.
Markup hiding can be toggled using C-c C-x C-m
(`markdown-toggle-markup-hiding`) or from the Markdown | Show &
Hide menu.
Unicode bullets are used to replace ASCII list item markers.
The list of characters used, in order of list level, can be
specified by setting the variable `markdown-list-item-bullets`.
The placeholder characters used to replace other markup can
be changed by customizing the corresponding variables:
`markdown-blockquote-display-char`,
`markdown-hr-display-char`, and
`markdown-definition-display-char`.
* `markdown-fontify-code-blocks-natively` - Whether to fontify
code in code blocks using the native major mode. This only
works for fenced code blocks where the language is specified
where we can automatically determine the appropriate mode to
use. The language to mode mapping may be customized by setting
the variable `markdown-code-lang-modes`. This can be toggled
interactively by pressing C-c C-x C-f
(`markdown-toggle-fontify-code-blocks-natively`).
* `markdown-gfm-uppercase-checkbox` - When non-nil, complete GFM
task list items with `[X]` instead of `[x]` (default: `nil`).
This is useful for compatibility with `org-mode`, which doesn't
recognize the lowercase variant.
* `markdown-translate-filename-function` - A function to be used to
translate filenames in links.
Additionally, the faces used for syntax highlighting can be modified to
your liking by issuing M-x customize-group RET markdown-faces
or by using the "Markdown Faces" link at the bottom of the mode
customization screen.
[Marked 2]: https://itunes.apple.com/us/app/marked-2/id890031187?mt=12&uo=4&at=11l5Vs&ct=mm
## Extensions
Besides supporting the basic Markdown syntax, Markdown Mode also
includes syntax highlighting for `[[Wiki Links]]`. This can be
enabled by setting `markdown-enable-wiki-links` to a non-nil value.
Wiki links may be followed by pressing C-c C-o when the point
is at a wiki link. Use M-p and M-n to quickly jump to the
previous and next links (including links of other types).
Aliased or piped wiki links of the form `[[link text|PageName]]`
are also supported. Since some wikis reverse these components, set
`markdown-wiki-link-alias-first` to nil to treat them as
`[[PageName|link text]]`. If `markdown-wiki-link-fontify-missing`
is also non-nil, Markdown Mode will highlight wiki links with
missing target file in a different color. By default, Markdown
Mode only searches for target files in the current directory.
Search in subdirectories can be enabled by setting
`markdown-wiki-link-search-subdirectories` to a non-nil value.
Sequential parent directory search (as in [Ikiwiki][]) can be
enabled by setting `markdown-wiki-link-search-parent-directories`
to a non-nil value.
[Ikiwiki]: https://ikiwiki.info
[SmartyPants][] support is possible by customizing `markdown-command`.
If you install `SmartyPants.pl` at, say, `/usr/local/bin/smartypants`,
then you can set `markdown-command` to `"markdown | smartypants"`.
You can do this either by using M-x customize-group markdown
or by placing the following in your `.emacs` file:
```lisp
(setq markdown-command "markdown | smartypants")
```
[SmartyPants]: http://daringfireball.net/projects/smartypants/
Syntax highlighting for mathematical expressions written
in LaTeX (only expressions denoted by `$..$`, `$$..$$`, or `\[..\]`)
can be enabled by setting `markdown-enable-math` to a non-nil value,
either via customize or by placing `(setq markdown-enable-math t)`
in `.emacs`, and then restarting Emacs or calling
`markdown-reload-extensions`.
## GitHub Flavored Markdown (GFM)
A [GitHub Flavored Markdown][GFM] mode, `gfm-mode`, is also
available. The GitHub implementation differs slightly from
standard Markdown in that it supports things like different
behavior for underscores inside of words, automatic linking of
URLs, strikethrough text, and fenced code blocks with an optional
language keyword.
The GFM-specific features above apply to `README.md` files, wiki
pages, and other Markdown-formatted files in repositories on
GitHub. GitHub also enables [additional features][GFM comments] for
writing on the site (for issues, pull requests, messages, etc.)
that are further extensions of GFM. These features include task
lists (checkboxes), newlines corresponding to hard line breaks,
auto-linked references to issues and commits, wiki links, and so
on. To make matters more confusing, although task lists are not
part of [GFM proper][GFM], [since 2014][] they are rendered (in a
read-only fashion) in all Markdown documents in repositories on the
site. These additional extensions are supported to varying degrees
by `markdown-mode` and `gfm-mode` as described below.
* **URL autolinking:** Both `markdown-mode` and `gfm-mode` support
highlighting of URLs without angle brackets.
* **Multiple underscores in words:** You must enable `gfm-mode` to
toggle support for underscores inside of words. In this mode
variable names such as `a_test_variable` will not trigger
emphasis (italics).
* **Fenced code blocks:** Code blocks quoted with backquotes, with
optional programming language keywords, are highlighted in
both `markdown-mode` and `gfm-mode`. They can be inserted with
C-c C-s C. If there is an active region, the text in the
region will be placed inside the code block. You will be
prompted for the name of the language, but may press enter to
continue without naming a language.
* **Strikethrough:** Strikethrough text is supported in both
`markdown-mode` and `gfm-mode`. It can be inserted (and toggled)
using C-c C-s s.
* **Task lists:** GFM task lists will be rendered as checkboxes
(Emacs buttons) in both `markdown-mode` and `gfm-mode` when
`markdown-make-gfm-checkboxes-buttons` is set to a non-nil value
(and it is set to t by default). These checkboxes can be
toggled by clicking `mouse-1`, pressing RET over the button,
or by pressing C-c C-d (`markdown-do`) with the point anywhere
in the task list item. A normal list item can be turned to a
check list item by the same command, or more specifically
C-c C-s [ (`markdown-insert-gfm-checkbox`).
* **Wiki links:** Generic wiki links are supported in
`markdown-mode`, but in `gfm-mode` specifically they will be
treated as they are on GitHub: spaces will be replaced by hyphens
in filenames and the first letter of the filename will be
capitalized. For example, `[[wiki link]]` will map to a file
named `Wiki-link` with the same extension as the current file.
If a file with this name does not exist in the current directory,
the first match in a subdirectory, if any, will be used instead.
* **Newlines:** Neither `markdown-mode` nor `gfm-mode` do anything
specifically with respect to newline behavior. If you use
`gfm-mode` mostly to write text for comments or issues on the
GitHub site--where newlines are significant and correspond to
hard line breaks--then you may want to enable `visual-line-mode`
for line wrapping in buffers. You can do this with a
`gfm-mode-hook` as follows:
```lisp
;; Use visual-line-mode in gfm-mode
(defun my-gfm-mode-hook ()
(visual-line-mode 1))
(add-hook 'gfm-mode-hook 'my-gfm-mode-hook)
```
* **Preview:** GFM-specific preview can be powered by setting
`markdown-command` to use [Docter][]. This may also be
configured to work with [Marked 2][] for `markdown-open-command`.
[GFM]: http://github.github.com/github-flavored-markdown/
[GFM comments]: https://help.github.com/articles/writing-on-github/
[since 2014]: https://github.com/blog/1825-task-lists-in-all-markdown-documents
[Docter]: https://github.com/alampros/Docter
## Acknowledgments
markdown-mode has benefited greatly from the efforts of the many
volunteers who have sent patches, test cases, bug reports,
suggestions, helped with packaging, etc. Thank you for your
contributions! See the [contributors graph][contrib] for details.
[contrib]: https://github.com/jrblevin/markdown-mode/graphs/contributors
## Bugs
markdown-mode is developed and tested primarily for compatibility
with GNU Emacs 24.4 and later. If you find any bugs in
markdown-mode, please construct a test case or a patch and open a
ticket on the [GitHub issue tracker][issues]. See the
contributing guidelines in `CONTRIBUTING.md` for details on
creating pull requests.
[issues]: https://github.com/jrblevin/markdown-mode/issues
## History
markdown-mode was written and is maintained by Jason Blevins. The
first version was released on May 24, 2007.
* 2007-05-24: [Version 1.1][]
* 2007-05-25: [Version 1.2][]
* 2007-06-05: [Version 1.3][]
* 2007-06-29: [Version 1.4][]
* 2007-10-11: [Version 1.5][]
* 2008-06-04: [Version 1.6][]
* 2009-10-01: [Version 1.7][]
* 2011-08-12: [Version 1.8][]
* 2011-08-15: [Version 1.8.1][]
* 2013-01-25: [Version 1.9][]
* 2013-03-24: [Version 2.0][]
* 2016-01-09: [Version 2.1][]
* 2017-05-26: [Version 2.2][]
* 2017-08-31: [Version 2.3][]
[Version 1.1]: https://jblevins.org/projects/markdown-mode/rev-1-1
[Version 1.2]: https://jblevins.org/projects/markdown-mode/rev-1-2
[Version 1.3]: https://jblevins.org/projects/markdown-mode/rev-1-3
[Version 1.4]: https://jblevins.org/projects/markdown-mode/rev-1-4
[Version 1.5]: https://jblevins.org/projects/markdown-mode/rev-1-5
[Version 1.6]: https://jblevins.org/projects/markdown-mode/rev-1-6
[Version 1.7]: https://jblevins.org/projects/markdown-mode/rev-1-7
[Version 1.8]: https://jblevins.org/projects/markdown-mode/rev-1-8
[Version 1.8.1]: https://jblevins.org/projects/markdown-mode/rev-1-8-1
[Version 1.9]: https://jblevins.org/projects/markdown-mode/rev-1-9
[Version 2.0]: https://jblevins.org/projects/markdown-mode/rev-2-0
[Version 2.1]: https://jblevins.org/projects/markdown-mode/rev-2-1
[Version 2.2]: https://jblevins.org/projects/markdown-mode/rev-2-2
[Version 2.3]: https://jblevins.org/projects/markdown-mode/rev-2-3
markdown-mode-2.3+154/markdown-mode.el 0000664 0000000 0000000 00001412232 13217531627 0017531 0 ustar 00root root 0000000 0000000 ;;; markdown-mode.el --- Major mode for Markdown-formatted text -*- lexical-binding: t; -*-
;; Copyright (C) 2007-2017 Jason R. Blevins and markdown-mode
;; contributors (see the commit log for details).
;; Author: Jason R. Blevins `--but they may add visual distinction and style to plain text documents. To maintain some notion of promotion and demotion, keep these sorted from largest to smallest. * `markdown-bold-underscore` - set to a non-nil value to use two underscores when inserting bold text instead of two asterisks (default: `nil`). * `markdown-italic-underscore` - set to a non-nil value to use underscores when inserting italic text instead of asterisks (default: `nil`). * `markdown-asymmetric-header` - set to a non-nil value to use asymmetric header styling, placing header characters only on the left of headers (default: `nil`). * `markdown-header-scaling` - set to a non-nil value to use a variable-pitch font for headings where the size corresponds to the level of the heading (default: `nil`). * `markdown-header-scaling-values` - list of scaling values, relative to baseline, for headers of levels one through six, used when `markdown-header-scaling` is non-nil (default: `(2.0 1.7 1.4 1.1 1.0 1.0)`). * `markdown-marginalize-headers` - put opening atx header markup in the left margin when non-nil (default: `nil`). * `markdown-marginalize-headers-margin-width` - width of margin used for marginalized headers (default: 6). * `markdown-list-indent-width` - depth of indentation for lists when inserting, promoting, and demoting list items (default: 4). * `markdown-indent-function` - the function to use for automatic indentation (default: `markdown-indent-line`). * `markdown-indent-on-enter` - Set to a non-nil value to automatically indent new lines when RET is pressed. Set to `indent-and-new-item` to additionally continue lists when RET is pressed (default: `t`). * `markdown-enable-wiki-links` - syntax highlighting for wiki links (default: `nil`). Set this to a non-nil value to turn on wiki link support by default. Wiki link support can be toggled later using the function `markdown-toggle-wiki-links`." * `markdown-wiki-link-alias-first` - set to a non-nil value to treat aliased wiki links like `[[link text|PageName]]` (default: `t`). When set to nil, they will be treated as `[[PageName|link text]]`. * `markdown-uri-types` - a list of protocol schemes (e.g., "http") for URIs that `markdown-mode` should highlight. * `markdown-enable-math` - font lock for inline and display LaTeX math expressions (default: `nil`). Set this to `t` to turn on math support by default. Math support can be toggled interactively later using C-c C-x C-e (`markdown-toggle-math`). * `markdown-enable-html` - font lock for HTML tags and attributes (default: `t`). * `markdown-css-paths` - CSS files to link to in XHTML output (default: `nil`). * `markdown-content-type` - when set to a nonempty string, an `http-equiv` attribute will be included in the XHTML `` block (default: `""`). If needed, the suggested values are `application/xhtml+xml` or `text/html`. See also: `markdown-coding-system`. * `markdown-coding-system` - used for specifying the character set identifier in the `http-equiv` attribute when included (default: `nil`). See `markdown-content-type`, which must be set before this variable has any effect. When set to `nil`, `buffer-file-coding-system` will be used to automatically determine the coding system string (falling back to `iso-8859-1` when unavailable). Common settings are `utf-8` and `iso-latin-1`. * `markdown-xhtml-header-content` - additional content to include in the XHTML `` block (default: `""`). * `markdown-xhtml-standalone-regexp` - a regular expression which `markdown-mode` uses to determine whether the output of `markdown-command` is a standalone XHTML document or an XHTML fragment (default: `"^\\(<\\?xml\\|C-c C-x C-l
`"
(markdown-test-range-has-face (1+ (point-min)) (- (point-max) 2) 'markdown-inline-code-face)))
(ert-deftest test-markdown-font-lock/inline-code-link ()
"Test links inside of inline code."
(markdown-test-string "`[text](url)`"
(markdown-test-range-has-face (1+ (point-min)) (- (point-max) 2) 'markdown-inline-code-face)
(should-not (markdown-range-property-any
(1+ (point-min)) (- (point-max) 2) 'face
'(markdown-markup-face markdown-link-face markdown-url-face)))))
(ert-deftest test-markdown-font-lock/comment-hanging-indent ()
"Test comments with hanging indentation."
(markdown-test-string ""
(markdown-test-range-has-face (point-min) (1- (point-max)) 'markdown-comment-face)))
(ert-deftest test-markdown-font-lock/comment-multiple ()
"Test multiple single-line comments in arow."
(markdown-test-string "\n"
(markdown-test-range-has-face
(point-at-bol) (1- (point-at-eol)) 'markdown-comment-face)
(forward-line)
(markdown-test-range-has-face
(point-at-bol) (1- (point-at-eol)) 'markdown-comment-face)))
(ert-deftest test-markdown-font-lock/comment-list-items ()
"Test comment with list inside."
(markdown-test-string
""
(markdown-test-range-face-equals (point-min) (1- (point-max))
'markdown-comment-face)))
(ert-deftest test-markdown-font-lock/comment-angle-bracket ()
"Regression test for GH-117."
(markdown-test-string ""
(markdown-test-range-face-equals (point-min) (1- (point-max))
'markdown-comment-face)))
(ert-deftest test-markdown-font-lock/comment-link ()
"Test links inside of comments."
(markdown-test-string ""
(markdown-test-range-has-face (+ (point-min) 5) (- (point-max) 4) 'markdown-comment-face)
(should-not (markdown-range-property-any
(+ (point-min) 5) (- (point-max) 4) 'face
'(markdown-markup-face markdown-link-face markdown-url-face)))))
(ert-deftest test-markdown-font-lock/footnote-markers-links ()
"Test an edge case involving footnote markers and inline reference links."
(markdown-test-string "Harvard[^1] [tuition][]"
(markdown-test-range-has-face 1 7 nil)
(markdown-test-range-has-face 8 8 'markdown-markup-face)
(markdown-test-range-has-face 10 10 'markdown-footnote-marker-face)
(markdown-test-range-has-face 11 11 'markdown-markup-face)
(markdown-test-range-has-face 12 12 nil)
(markdown-test-range-has-face 13 13 'markdown-markup-face)
(markdown-test-range-has-face 14 20 'markdown-link-face)
(markdown-test-range-has-face 21 21 'markdown-markup-face)
(markdown-test-range-has-face 22 23 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/mmd-metadata ()
"Basic MultMarkdown metadata tests."
(markdown-test-string "Title: peg-multimarkdown User's Guide
Author: Fletcher T. Penney
Base Header Level: 2"
(markdown-test-range-has-face 1 5 'markdown-metadata-key-face)
(markdown-test-range-has-face 6 6 'markdown-markup-face)
(markdown-test-range-has-face 8 37 'markdown-metadata-value-face)
(markdown-test-range-has-face 39 44 'markdown-metadata-key-face)
(markdown-test-range-has-face 46 46 'markdown-markup-face)
(markdown-test-range-has-face 47 64 'markdown-metadata-value-face)
(markdown-test-range-has-face 66 82 'markdown-metadata-key-face)
(markdown-test-range-has-face 83 83 'markdown-markup-face)
(markdown-test-range-has-face 85 85 'markdown-metadata-value-face))
;; Avoid triggering when a title contains a colon (e.g., Markdown: Syntax)
(markdown-test-file "syntax.text"
(markdown-test-range-has-face 1 16 'markdown-header-face-1)))
(ert-deftest test-markdown-font-lock/mmd-metadata-after-header ()
"Ensure that similar lines are not matched after the header."
(markdown-test-string "Title: peg-multimarkdown User's Guide
Author: Fletcher T. Penney
Base Header Level: 2"
(markdown-test-range-has-face 1 5 'markdown-metadata-key-face)
(markdown-test-range-has-face 6 6 'markdown-markup-face)
(markdown-test-range-has-face 8 37 'markdown-metadata-value-face)
(markdown-test-range-has-face 40 65 nil)
(markdown-test-range-has-face 67 86 nil)))
(ert-deftest test-markdown-font-lock/mmd-metadata-after-header-with-whitespace ()
"Ensure that similar lines are not matched after the header.
The blank line here has two spaces, which should not change how
it is parsed."
(markdown-test-string
"Title: peg-multimarkdown User's Guide\n \nAuthor: Fletcher T. Penney\nBase Header Level: 2\n"
(markdown-test-range-has-face 1 5 'markdown-metadata-key-face)
(markdown-test-range-has-face 6 6 'markdown-markup-face)
(markdown-test-range-has-face 8 37 'markdown-metadata-value-face)
(markdown-test-range-has-face 42 67 nil)
(markdown-test-range-has-face 69 88 nil)))
(ert-deftest test-markdown-font-lock/pandoc-metadata ()
"Basic Pandoc metadata tests."
(markdown-test-string "% title
two-line title
% first author;
second author
% date
body"
(markdown-test-range-has-face 1 1 'markdown-markup-face)
(markdown-test-range-has-face 3 24 'markdown-metadata-value-face)
(markdown-test-range-has-face 26 26 'markdown-markup-face)
(markdown-test-range-has-face 28 56 'markdown-metadata-value-face)
(markdown-test-range-has-face 58 58 'markdown-markup-face)
(markdown-test-range-has-face 60 63 'markdown-metadata-value-face)
(markdown-test-range-has-face 64 69 nil)))
(ert-deftest test-markdown-font-lock/yaml-metadata ()
"Basic YAML metadata tests."
(markdown-test-string
"---
layout: post
date: 2015-08-13 11:35:25 EST
---
"
(markdown-test-range-has-face 1 3 'markdown-markup-face)
(markdown-test-range-has-face 5 10 'markdown-metadata-key-face)
(markdown-test-range-has-face 11 11 'markdown-markup-face)
(markdown-test-range-has-face 13 16 'markdown-metadata-value-face)
(markdown-test-range-has-face 18 21 'markdown-metadata-key-face)
(markdown-test-range-has-face 22 22 'markdown-markup-face)
(markdown-test-range-has-face 24 46 'markdown-metadata-value-face)
(markdown-test-range-has-face 48 50 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/toml-metadata ()
"Basic TOML metadata tests."
(markdown-test-string
"---
layout = post
date = 2015-08-13 11:35:25 EST
---
"
(markdown-test-range-has-face 1 3 'markdown-markup-face)
(markdown-test-range-has-face 5 10 'markdown-metadata-key-face)
(markdown-test-range-has-face 12 12 'markdown-markup-face)
(markdown-test-range-has-face 14 17 'markdown-metadata-value-face)
(markdown-test-range-has-face 19 22 'markdown-metadata-key-face)
(markdown-test-range-has-face 24 24 'markdown-markup-face)
(markdown-test-range-has-face 26 48 'markdown-metadata-value-face)
(markdown-test-range-has-face 50 52 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/pandoc-yaml-metadata ()
"Basic yaml metadata tests, with pandoc syntax."
(let ((markdown-use-pandoc-style-yaml-metadata t))
(markdown-test-string
"some text
---
layout: post
date: 2015-08-13 11:35:25 EST
...
more text
---
layout: post
date: 2015-08-13 11:35:25 EST
---
But this is merely a code block
```
---
layout: post
date: 2015-08-13 11:35:25 EST
---
```
"
;; first section
(markdown-test-range-has-face 12 14 'markdown-markup-face)
(markdown-test-range-has-face 16 21 'markdown-metadata-key-face)
(markdown-test-range-has-face 22 22 'markdown-markup-face)
(markdown-test-range-has-face 24 27 'markdown-metadata-value-face)
(markdown-test-range-has-face 29 32 'markdown-metadata-key-face)
(markdown-test-range-has-face 33 33 'markdown-markup-face)
(markdown-test-range-has-face 35 57 'markdown-metadata-value-face)
(markdown-test-range-has-face 59 61 'markdown-markup-face)
;; second section
(markdown-test-range-has-face 75 77 'markdown-markup-face)
(markdown-test-range-has-face 79 84 'markdown-metadata-key-face)
(markdown-test-range-has-face 85 85 'markdown-markup-face)
(markdown-test-range-has-face 87 90 'markdown-metadata-value-face)
(markdown-test-range-has-face 92 95 'markdown-metadata-key-face)
(markdown-test-range-has-face 96 96 'markdown-markup-face)
(markdown-test-range-has-face 98 120 'markdown-metadata-value-face)
(markdown-test-range-has-face 122 124 'markdown-markup-face)
;; third section
(markdown-test-range-has-face 160 162 'markdown-markup-face)
(markdown-test-range-has-face 164 213 'markdown-pre-face)
(markdown-test-range-has-face 215 217 'markdown-markup-face))))
(ert-deftest test-markdown-font-lock/line-break ()
"Basic line break tests."
(markdown-test-string " \nasdf \n"
(markdown-test-range-has-face 1 9 nil)
(markdown-test-range-has-face 10 11 'markdown-line-break-face)))
(ert-deftest test-markdown-font-lock/blockquote-bold ()
"Test font lock for bold inside of a blockquote."
(markdown-test-string
"> **bold**"
(markdown-test-range-has-face 1 10 'markdown-blockquote-face)
(markdown-test-range-has-face 5 8 'markdown-bold-face)))
(ert-deftest test-markdown-font-lock/blockquote-italic ()
"Test font lock for italic inside of a blockquote."
(markdown-test-string
"> *italic*"
(markdown-test-range-has-face 1 10 'markdown-blockquote-face)
(markdown-test-range-has-face 4 9 'markdown-italic-face)))
(ert-deftest test-markdown-font-lock/blockquote-code ()
"Test font lock for inline code inside of a blockquote."
(markdown-test-string
"> `code`"
(markdown-test-range-has-face 1 8 'markdown-blockquote-face)
(markdown-test-range-has-face 3 3 'markdown-markup-face)
(markdown-test-range-has-face 4 7 'markdown-inline-code-face)
(markdown-test-range-has-face 8 8 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/blockquote-link ()
"Test font lock for links inside of a blockquote.
This test will fail until font lock for inline links inside
blockquotes is implemented (at present, the blockquote face
takes precedence)."
(markdown-test-string
"> [link](url)"
(markdown-test-range-has-face 1 1 'markdown-markup-face)
(markdown-test-range-has-face 2 13 'markdown-blockquote-face)
(markdown-test-range-has-face 3 3 'markdown-markup-face)
(markdown-test-range-has-face 4 7 'markdown-link-face)
(markdown-test-range-has-face 8 9 'markdown-markup-face)
(markdown-test-range-has-face 10 12 'markdown-url-face)
(markdown-test-range-has-face 13 13 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/blockquote-comment ()
"Test font lock for comments inside of a blockquote."
(markdown-test-string
"> "
(markdown-test-range-has-face 1 1 'markdown-markup-face)
(markdown-test-range-has-face 3 18 'markdown-comment-face)))
(ert-deftest test-markdown-font-lock/pre-override ()
"Test that font lock for pre blocks overrides everything else."
(markdown-test-string
" **bold**
_italic_
[link](url)
* list"
(markdown-test-range-has-face 1 73 'markdown-pre-face)))
(ert-deftest test-markdown-font-lock/gfm-code-block-font-lock ()
"GFM code block font lock test. Now in base markdown-mode as well!"
(markdown-test-file "gfm.text"
(markdown-test-range-has-face 2639 2641 'markdown-markup-face) ; ```
(markdown-test-range-has-face 2642 2645 'markdown-language-keyword-face) ; lang
(markdown-test-range-has-face 2647 2728 'markdown-pre-face) ; code
(markdown-test-range-has-face 2730 2732 'markdown-markup-face))) ; ```
(ert-deftest test-markdown-font-lock/reference-definition ()
"Reference definitions should not include ]."
(let ((markdown-hide-urls nil))
(markdown-test-string "[1]: http://daringfireball.net/ \"title\""
(markdown-test-range-has-face 2 2 'markdown-reference-face) ; 1
(markdown-test-range-has-face 6 31 'markdown-url-face) ; URL
(markdown-test-range-has-face 34 38 'markdown-link-title-face)) ; title
(markdown-test-string "[foo][1] and [bar][2]: not a reference definition"
(markdown-test-range-has-face 2 4 'markdown-link-face) ; foo
(markdown-test-range-has-face 7 7 'markdown-reference-face) ; 1
(markdown-test-range-has-face 9 13 nil) ; [ ]and[ ]
(markdown-test-range-has-face 15 17 'markdown-link-face) ; bar
(markdown-test-range-has-face 20 20 'markdown-reference-face) ; 2
(markdown-test-range-has-face 22 49 nil)))) ; [ ]and[ ]
(ert-deftest test-markdown-font-lock/subscripts ()
"Test font lock for subscripts."
(markdown-test-string "H~2~0"
(markdown-test-range-has-face 2 2 'markdown-markup-face) ; First ~
(markdown-test-range-has-face 3 3 nil) ; 2
(markdown-test-range-has-face 4 4 'markdown-markup-face))) ; Second ~
(ert-deftest test-markdown-font-lock/superscripts ()
"Test font lock for subscripts."
(markdown-test-string "334^10^"
(markdown-test-range-has-face 1 3 nil) ; 334
(markdown-test-range-has-face 4 4 'markdown-markup-face) ; First ^
(markdown-test-range-has-face 5 6 nil) ; 10
(markdown-test-range-has-face 7 7 'markdown-markup-face))) ; Second ^
(ert-deftest test-markdown-font-lock/hidden-urls-inline ()
"Test URL hiding and toggling."
(let ((markdown-hide-urls t))
(markdown-test-file "inline.text"
(markdown-test-range-has-face 925 925 'markdown-markup-face)
(markdown-test-range-has-face 926 929 'markdown-link-face)
(markdown-test-range-has-face 930 931 'markdown-markup-face)
(markdown-test-range-has-face 932 949 'markdown-url-face)
(markdown-test-range-has-face 951 957 'markdown-link-title-face)
(markdown-test-range-has-face 958 958 'markdown-markup-face)
(should (get-text-property 932 'composition)))))
(ert-deftest test-markdown-font-lock/hidden-urls-reference ()
"Test URL hiding and toggling."
(let ((markdown-hide-urls t))
(markdown-test-string "[link][15]"
;; Two-character reference labels shouldn't get composed.
(markdown-test-range-has-face 1 1 'markdown-markup-face)
(markdown-test-range-has-face 2 5 'markdown-link-face)
(markdown-test-range-has-face 6 7 'markdown-markup-face)
(markdown-test-range-has-face 8 9 'markdown-reference-face)
(markdown-test-range-has-face 10 10 'markdown-markup-face)
(should-not (get-text-property 8 'composition)))
(markdown-test-string "[link][long-reference-label]"
;; Longer reference labels should be composed
(markdown-test-range-has-face 1 1 'markdown-markup-face)
(markdown-test-range-has-face 2 5 'markdown-link-face)
(markdown-test-range-has-face 6 7 'markdown-markup-face)
(markdown-test-range-has-face 8 27 'markdown-reference-face)
(markdown-test-range-has-face 28 28 'markdown-markup-face)
(should (get-text-property 8 'composition)))))
(ert-deftest test-markdown-font-lock/snake-case-code-in-heading ()
"Test underscores in inline code in headings."
(markdown-test-string "# Title with `snake_case_code`"
(should-not (markdown-range-property-any 21 24 'face '(markdown-italic-face)))
(markdown-test-range-has-face 15 29 'markdown-inline-code-face)))
(ert-deftest test-markdown-font-lock/stars-in-code-in-heading ()
"Test asterisks in inline code in headings."
(markdown-test-string "# Title with `char** foo, int* bar`"
(should-not (markdown-range-property-any 20 29 'face '(markdown-italic-face)))
(markdown-test-range-has-face 15 34 'markdown-inline-code-face)))
(ert-deftest test-markdown-font-lock/stars-in-code-in-blockquote ()
"Test asterisks in inline code in blockquote."
(markdown-test-string "> Quote with `**stars**`"
(should-not (markdown-range-property-any
17 21 'face '(markdown-italic-face markdown-bold-face)))
(markdown-test-range-has-face 15 23 'markdown-inline-code-face)))
(ert-deftest test-markdown-font-lock/two-bold-words-after-list ()
"Test two bold words after a list marker."
(markdown-test-string "- **foo** **bar**"
(should-not (markdown-range-property-any
(point-min) (point-max) 'face '(markdown-italic-face)))))
(ert-deftest test-markdown-font-lock/heading-with-italics-and-bold ()
"Test two bold words after a list marker."
(markdown-test-string "# Title with *italics* and **bold**"
(markdown-test-range-has-face 15 21 'markdown-italic-face)
(markdown-test-range-has-face 30 33 'markdown-bold-face)
(should-not (markdown-range-property-any 30 33 'face '(markdown-italic-face)))))
(ert-deftest test-markdown-font-lock/heading-with-italics-and-bold ()
"Test that HRs are distinguished from setext H2 markup."
(markdown-test-file "outline.text"
(goto-char 485)
(should (markdown-on-heading-p))
(beginning-of-line)
(should (markdown-on-heading-p))
(should-not (markdown-range-property-any 453 484 'face '(markdown-hr-face)))))
(ert-deftest test-markdown-font-lock/heading-code-block-no-whitespace ()
"Headings immediately before code blocks should be identified correctly.
See GH-234."
(markdown-test-string
"#### code snippet
```javascript
const styles = require('gadgets/dist/styles.css');
```"
(goto-char (point-min))
(forward-word)
(should (markdown-on-heading-p))
(should (markdown-match-propertized-text 'markdown-heading (point-at-eol)))
(goto-char (match-beginning 0))
(should (markdown-outline-level))
(should (= (markdown-outline-level) 4))
(markdown-test-range-has-face 6 17 'markdown-header-face-4)
(end-of-line)
(should-not (markdown-code-block-at-point-p))))
(ert-deftest test-markdown-font-lock/hr-underscore-with-spaces ()
"Test font-lock for HR with spaced underscores."
(markdown-test-string "_ _ _ _ _ _ _\n"
(markdown-test-range-face-equals (point-min) (- (point-max) 2) 'markdown-hr-face)))
(ert-deftest test-markdown-font-lock/hr-underscore-no-spaces ()
"Test font-lock for HR with underscores and no spaces."
(markdown-test-string "_____________\n"
(markdown-test-range-face-equals (point-min) (- (point-max) 2) 'markdown-hr-face)))
(ert-deftest test-markdown-font-lock/inline-attributes ()
"Test inline attributes before a fenced code block."
(markdown-test-file "Leanpub.md"
;; Inline attributes for a heading
(markdown-test-range-has-face 38 42 'markdown-markup-face)
;; Inline attributes inside an aside block
(markdown-test-range-has-face 123 141 'markdown-markup-face)
;; Inline attributes before a fenced code block
(markdown-test-range-has-face 632 696 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/leanpub-sections ()
"Test Leanpub section markers."
(markdown-test-file "Leanpub.md"
;; {frontmatter}
(markdown-test-range-has-face 12 24 'markdown-markup-face)
;; {mainmatter}
(markdown-test-range-has-face 69 80 'markdown-markup-face)
;; {pagebreak}
(markdown-test-range-has-face 427 437 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/leanpub-include ()
"Test Leanpub include syntax."
(markdown-test-file "Leanpub.md"
;; no title
(markdown-test-range-has-face 561 563 'markdown-markup-face)
(markdown-test-range-has-face 564 577 'markdown-url-face)
(markdown-test-range-has-face 578 578 'markdown-markup-face)
;; title
(markdown-test-range-has-face 581 583 'markdown-markup-face)
(markdown-test-range-has-face 584 611 'markdown-link-title-face)
(markdown-test-range-has-face 612 613 'markdown-markup-face)
(markdown-test-range-has-face 614 628 'markdown-url-face)
(markdown-test-range-has-face 629 629 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/curly-brace-include ()
"Test curly brace include syntax."
(markdown-test-string "<<{file}"
(markdown-test-range-has-face 1 3 'markdown-markup-face)
(markdown-test-range-has-face 4 7 'markdown-url-face)
(markdown-test-range-has-face 8 8 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/square-bracket-include ()
"Test square bracket include syntax."
(markdown-test-string "<<[file]"
(markdown-test-range-has-face 1 3 'markdown-markup-face)
(markdown-test-range-has-face 4 7 'markdown-url-face)
(markdown-test-range-has-face 8 8 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/pandoc-inline-footnote ()
"Test font lock for Pandoc inline footnotes."
(markdown-test-string "Here is an inline note.^[Inline notes are easier to write, since
you don't have to pick an identifier and move down to type the
note.] And then you can close it and continue writing."
(markdown-test-range-has-face 1 23 nil)
(markdown-test-range-has-face 24 25 'markdown-markup-face)
(markdown-test-range-has-face 26 133 'markdown-footnote-text-face)
(markdown-test-range-has-face 134 134 'markdown-markup-face)))
(ert-deftest test-markdown-font-lock/pandoc-inline-footnote-across-block ()
"Test font lock for Pandoc inline footnotes."
(markdown-test-string "Inline notes should not^[match
across blocks]"
(markdown-test-range-has-face (point-min) (point-max) nil)))
(ert-deftest test-markdown-font-lock/html-entity-named ()
"Test basic font-lock support for named HTML entities."
(markdown-test-string " "
(markdown-test-range-has-face 1 6 'markdown-html-entity-face)))
(ert-deftest test-markdown-font-lock/html-entity-hex ()
"Test basic font-lock support for hexadecimal HTML entities."
(markdown-test-string "✪"
(markdown-test-range-has-face 1 8 'markdown-html-entity-face)))
(ert-deftest test-markdown-font-lock/html-entity-decimal ()
"Test basic font-lock support for decimal HTML entities."
(markdown-test-string " "
(markdown-test-range-has-face 1 4 'markdown-html-entity-face)))
(ert-deftest test-markdown-font-lock/html-entity-in-inline-code ()
"Test that HTML entities are not matched inside inline code."
(markdown-test-string "` `"
(markdown-test-range-has-face 1 1 'markdown-markup-face)
(markdown-test-range-has-face 2 5 'markdown-inline-code-face)
(markdown-test-range-has-face 6 6 'markdown-markup-face)
(should-not (markdown-range-property-any 1 6 'face '(markdown-html-entity-face)))))
(ert-deftest test-markdown-font-lock/html-entity-in-gfm-code-block ()
"Test that HTML entities are not matched inside GFM code blocks."
(markdown-test-string "```\n \n✪\n \n```"
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face '(markdown-html-entity-face)))))
(ert-deftest test-markdown-font-lock/html-tags-in-syntax-file ()
"Test matching HTML tags in syntax.text."
(markdown-test-file "syntax.text"
;;
(markdown-test-range-has-face 36 36 'markdown-html-tag-delimiter-face)
(markdown-test-range-has-face 37 38 'markdown-html-tag-name-face)
(markdown-test-range-has-face 40 41 'markdown-html-attr-name-face)
(markdown-test-range-has-face 42 42 'markdown-html-tag-delimiter-face)
(markdown-test-range-has-face 43 58 'markdown-html-attr-value-face)
(markdown-test-range-has-face 59 59 'markdown-html-tag-delimiter-face)
;; -
(markdown-test-range-has-face 65 65 'markdown-html-tag-delimiter-face)
(markdown-test-range-has-face 66 67 'markdown-html-tag-name-face)
(markdown-test-range-has-face 68 68 'markdown-html-tag-delimiter-face)
;;
(markdown-test-range-has-face 69 69 'markdown-html-tag-delimiter-face)
(markdown-test-range-has-face 70 70 'markdown-html-tag-name-face)
(markdown-test-range-has-face 72 75 'markdown-html-attr-name-face)
(markdown-test-range-has-face 76 76 'markdown-html-tag-delimiter-face)
(markdown-test-range-has-face 77 97 'markdown-html-attr-value-face)
(markdown-test-range-has-face 99 103 'markdown-html-attr-name-face)
(markdown-test-range-has-face 104 104 'markdown-html-tag-delimiter-face)
(markdown-test-range-has-face 105 127 'markdown-html-attr-value-face)
(markdown-test-range-has-face 128 128 'markdown-html-tag-delimiter-face)))
(ert-deftest test-markdown-font-lock/html-tag-in-gfm-code-block ()
"Test that HTML tags are not matched inside GFM code blocks."
(markdown-test-string "```\n
\n```"
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face)))))
(ert-deftest test-markdown-font-lock/html-tag-in-code-block ()
"Test that HTML tags are not matched inside code blocks."
(markdown-test-string " "
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face)))))
(ert-deftest test-markdown-font-lock/html-tag-in-inline-code ()
"Test that HTML tags are not matched inside inline code spans."
(markdown-test-string "``"
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face)))))
(ert-deftest test-markdown-font-lock/html-disabled ()
"Test disabling font-lock for HTML tags"
(let ((markdown-enable-html nil))
(markdown-test-file "syntax.text"
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face))))))
;;; Markdown Parsing Functions:
(ert-deftest test-markdown-parsing/extend-region-function ()
"Test `markdown-syntax-propertize-extend-region'.
Should return a cons (NEW-START . NEW-END) or nil if no
adjustment should be made. Function is called repeatedly until it
returns nil."
(markdown-test-file
"inline.text"
(should (equal (markdown-syntax-propertize-extend-region 1 17)
(cons 1 91)))
(should (equal (markdown-syntax-propertize-extend-region 2 17)
(cons 1 91)))
(should (equal (markdown-syntax-propertize-extend-region 1 91)
nil))
(should (equal (markdown-syntax-propertize-extend-region 93 157)
nil))
(should (equal (markdown-syntax-propertize-extend-region 496 502)
(cons 486 510)))
(should (equal (markdown-syntax-propertize-extend-region 486 510)
nil))
;; Region that begins and ends with \n\n should not be extended
(should (equal (markdown-syntax-propertize-extend-region 157 355)
nil))))
(defun markdown-test-check-match-limits (prop num begin end &optional pos)
(let* ((posn (or pos (point)))
(props (get-text-property posn prop)))
(save-match-data
(set-match-data props)
(should (match-beginning num))
(should (match-end num))
(should (= (match-beginning num) begin))
(should (= (match-end num) end)))))
(ert-deftest test-markdown-parsing/syntax-with-adjacent-code-blocks ()
"Test `markdown-syntax-propertize-fenced-code-blocks' with adjacent blocks."
(markdown-test-string
"~~~ shell
#!/bin/sh
echo \"Hello, world!\"
~~~
~~~ shell
#!/bin/sh
echo \"Hello, world v2!\"
~~~
"
(let ((start-top-1 (make-marker)) (end-top-1 (make-marker))
(start-lang-1 (make-marker)) (end-lang-1 (make-marker))
(start-mid-1 (make-marker)) (end-mid-1 (make-marker))
(start-bottom-1 (make-marker)) (end-bottom-1 (make-marker))
(between (make-marker))
(start-top-2 (make-marker)) (end-top-2 (make-marker))
(start-lang-2 (make-marker)) (end-lang-2 (make-marker))
(start-mid-2 (make-marker)) (end-mid-2 (make-marker))
(start-bottom-2 (make-marker)) (end-bottom-2 (make-marker)))
;; First code block
(set-marker start-top-1 1)
(set-marker end-top-1 4)
(set-marker start-lang-1 5)
(set-marker end-lang-1 10)
(set-marker start-mid-1 11)
(set-marker end-mid-1 43)
(set-marker start-bottom-1 43)
(set-marker end-bottom-1 46)
;; check top tildes
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-1)
(marker-position end-top-1) (marker-position start-top-1))
;; check top language specifier
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-1)
(marker-position end-lang-1) (marker-position start-lang-1))
;; check text in between
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-1)
(marker-position end-mid-1) (marker-position start-mid-1))
;; check bottom tildes
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-1)
(marker-position end-bottom-1) (marker-position start-bottom-1))
;; Point between code blocks
(set-marker between 47)
(should (equal (get-text-property between 'markdown-fenced-code)
nil))
;; Second code block
(set-marker start-top-2 48)
(set-marker end-top-2 51)
(set-marker start-lang-2 52)
(set-marker end-lang-2 57)
(set-marker start-mid-2 58)
(set-marker end-mid-2 93)
(set-marker start-bottom-2 93)
(set-marker end-bottom-2 96)
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-2)
(marker-position end-top-2) (marker-position start-top-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-2)
(marker-position end-lang-2) (marker-position start-lang-2))
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-2)
(marker-position end-mid-2) (marker-position start-mid-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-2)
(marker-position end-bottom-2) (marker-position start-bottom-2))
;; ;; Move point between code blocks and insert a character
(goto-char between)
(insert "x")
;; Re-propertize region after change
(let ((range (markdown-syntax-propertize-extend-region (1- between) (point-max))))
(markdown-syntax-propertize (car range) (cdr range)))
;; Re-check first code block
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-1)
(marker-position end-top-1) (marker-position start-top-1))
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-1)
(marker-position end-lang-1) (marker-position start-lang-1))
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-1)
(marker-position end-mid-1) (marker-position start-mid-1))
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-1)
(marker-position end-bottom-1) (marker-position start-bottom-1))
;; Re-check point between code blocks
(should (equal (get-text-property between 'markdown-fenced-code)
nil))
;; Re-check second code block
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-2)
(marker-position end-top-2) (marker-position start-top-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-2)
(marker-position end-lang-2) (marker-position start-lang-2))
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-2)
(marker-position end-mid-2) (marker-position start-mid-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-2)
(marker-position end-bottom-2)
(marker-position start-bottom-2)))))
(ert-deftest test-markdown-parsing/propertize-fenced-in-between ()
"Test whether `markdown-syntax-propertize-fenced-block-constructs' handles the
case when it can't propertize both the start and end of a fenced block within a
single pass (the end of the block is past the END argument)."
(markdown-test-string
"~~~ shell
#!/bin/sh
echo \"Hello, world!\"
~~~
"
(set-text-properties (point-min) (point-max) nil)
;; syntax-propertize up to right after hashbang
(markdown-syntax-propertize-fenced-block-constructs (point-min) 21)
;; ~~~ shell should be propertized, but nothing else
;; check tildes
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 1 1 4 1)
;; check language
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 3 5 10 5)
;; middle should not be propertized
(should-not (get-text-property 11 'markdown-fenced-code))
;; neither should end
(should-not (get-text-property 43 'markdown-tilde-fence-end))
(markdown-syntax-propertize-fenced-block-constructs 21 (point-max))
;; everything should be propertized now
;; re-check top
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 1 1 4 1)
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 3 5 10 5)
;; check middle
(markdown-test-check-match-limits 'markdown-fenced-code 0 10 43 10)
;; check ending tildes
(markdown-test-check-match-limits 'markdown-tilde-fence-end 1 43 46 43)))
(ert-deftest test-markdown-parsing/get-code-block-at-pos ()
"Test whether `markdown-code-block-at-pos' works in all situations. All
situations are:
1. pre block
2. tilde block
3. gfm block
4. yaml metadata block"
(let ((markdown-use-pandoc-style-yaml-metadata t))
(markdown-test-string
"
~~~ ruby
some_ruby_fun()
~~~
---
a: b
---
``` {.bash}
#!/bin/sh
echo hey
```
pre code
random stuff
more preformatted code
---
data: pandoc
...
"
;; start/mid/end at tilde block
(should (equal (markdown-code-block-at-pos 2) (list 2 30)))
(should (equal (markdown-code-block-at-pos 11) (list 2 30)))
(should (equal (markdown-code-block-at-pos 27) (list 2 30)))
;; yaml metadata block
(should (equal (markdown-code-block-at-pos 32) (list 32 44)))
(should (equal (markdown-code-block-at-pos 36) (list 32 44)))
(should (equal (markdown-code-block-at-pos 41) (list 32 44)))
;; gfm block
(should (equal (markdown-code-block-at-pos 46) (list 46 80)))
(should (equal (markdown-code-block-at-pos 58) (list 46 80)))
(should (equal (markdown-code-block-at-pos 77) (list 46 80)))
;; pre block
(should (equal (markdown-code-block-at-pos 82) (list 82 138)))
(should (equal (markdown-code-block-at-pos 99) (list 82 138)))
(should (equal (markdown-code-block-at-pos 137) (list 82 138)))
;; pandoc yaml metadata block (should work if yaml above works)
(should (equal (markdown-code-block-at-pos 140) (list 140 160)))
(should (equal (markdown-code-block-at-pos 142) (list 140 160)))
(should (equal (markdown-code-block-at-pos 144) (list 140 160)))
(should (equal (markdown-code-block-at-pos 157) (list 140 160)))
(should (equal (markdown-code-block-at-pos 159) (list 140 160))))))
(ert-deftest test-markdown-parsing/syntax-get-fenced-blocks ()
"Test whether *-get-fenced-block-* functions work in the case where a block is
only partially propertized."
(save-match-data
(markdown-test-string
"~~~
"
(should (equal (markdown-syntax-propertize-extend-region
(point-min) (point-max))
nil))
(goto-char 1)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-begin))
(should (equal (markdown-get-fenced-block-from-start
'markdown-tilde-fence-begin)
nil)))
(markdown-test-string
"~~~
~~~"
(goto-char 1)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-begin))
(should (equal (markdown-get-fenced-block-from-start
'markdown-tilde-fence-begin)
(list 1 8)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 8)))
;; markdown-code-block-at-point-p should not modify match data
(set-match-data (list 1 2 3 4))
(should (markdown-code-block-at-point-p))
(should (equal (match-data) (list 1 2 3 4)))
(goto-char 5)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-end))
(should (equal (markdown-get-fenced-block-from-end
'markdown-tilde-fence-end)
(list 1 8)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 8))))
(markdown-test-string
"~~~
~~~"
(goto-char 1)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-begin))
(should (equal (markdown-get-fenced-block-from-start
'markdown-tilde-fence-begin)
(list 1 9)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 9)))
(goto-char 5)
(set-match-data (markdown-text-property-at-point 'markdown-fenced-code))
(should (equal (markdown-get-fenced-block-from-middle
'markdown-fenced-code)
(list 1 9)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 9)))
(goto-char 6)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-end))
(should (equal (markdown-get-fenced-block-from-end
'markdown-tilde-fence-end)
(list 1 9)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 9))))))
(ert-deftest test-markdown-parsing/reference-definition-basic ()
"Test reference definition function."
(markdown-test-file "syntax.text"
;; Test accuracy of returned text and bounds
(should (equal (markdown-reference-definition "1")
(list "http://docutils.sourceforge.net/mirror/setext.html" 1942 1992)))
(should (equal (markdown-reference-definition "2")
(list "http://www.aaronsw.com/2002/atx/" 2000 2032)))
;; Test that match data remains intact
(should (string-equal (match-string 5) "http://www.aaronsw.com/2002/atx/"))
;; Test anchor-only relative URL
(should (equal (markdown-reference-definition "bq")
(list "#blockquote" 7536 7547)))
;; Example references that appear in pre blocks in the text
(should (not (markdown-reference-definition "")))
(should (not (markdown-reference-definition "id")))
(should (not (markdown-reference-definition "foo")))
(should (not (markdown-reference-definition "A")))
(should (not (markdown-reference-definition "Google")))
;; Test that we don't pick up other text in square brackets
(should (not (markdown-reference-definition "blockquoting")))
(should (not (markdown-reference-definition "square brackets")))
;; Test case insensitivity
(should (equal (markdown-reference-definition "SRC")
(list "/projects/markdown/syntax.text" 1245 1275)))))
(ert-deftest test-markdown-parsing/get-defined-references ()
"Test `markdown-get-defined-references'."
(markdown-test-file "syntax.text"
(should (equal (markdown-get-defined-references)
'("src" "1" "2" "3" "4" "5" "6" "bq" "l"))))
(markdown-test-file "outline.text"
(should (equal (markdown-get-defined-references) nil)))
(markdown-test-file "wiki-links.text"
(should (equal (markdown-get-defined-references) nil))))
(ert-deftest test-markdown-parsing/get-used-uris ()
"Test `markdown-get-used-uris'."
(markdown-test-file "syntax.text"
(let ((uris (markdown-get-used-uris)))
(should (equal (nth 0 uris) "#overview"))
(should (equal (nth 20 uris) "http://www.aaronsw.com/2002/atx/"))
(should-not (member "http://example.com/" uris))
(should-not (member "address@example.com" uris)))))
(defun markdown-test-test-region (beg end)
(goto-char (1- beg))
(should-not (markdown-inline-code-at-point-p))
(goto-char (1+ end))
(should-not (markdown-inline-code-at-point-p))
(dolist (loc (number-sequence beg end))
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-beginning 0) beg))
(should (equal (match-end 0) end))))
(ert-deftest test-markdown-parsing/inline-code-at-point ()
"Test `markdown-inline-code-at-point'."
(markdown-test-file "inline.text"
(markdown-test-test-region 45 51) ; Regular code span
(markdown-test-test-region 61 90) ; Code containing backticks
(markdown-test-test-region 228 240) ; Backquotes at beginning
(markdown-test-test-region 341 352) ; Backquotes at end
(markdown-test-test-region 460 469) ; Backslash as final character
(markdown-test-test-region 657 667) ; A code span crossing lines
(markdown-test-test-region 749 758) ; Three backquotes on same line
(markdown-test-test-region 806 815) ; Three backquotes across lines
))
(ert-deftest test-markdown-parsing/inline-code-at-point-one-space ()
"Test `markdown-inline-code-at-point' with multiple code spans in a row."
(markdown-test-string "`foo` `bar` `baz`"
(dolist (loc (number-sequence 1 6))
(goto-char loc)
;; markdown-inline-code-at-point should set match data
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 1 6 1 2 2 5 5 6)))
;; markdown-inline-code-at-point-p should not modify match data
(set-match-data (list 1 2 3 4))
(should (markdown-inline-code-at-point-p))
(should (equal (match-data) (list 1 2 3 4))))
(dolist (loc (number-sequence 7 12))
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 7 12 7 8 8 11 11 12))))
(dolist (loc (number-sequence 13 18))
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 13 18 13 14 14 17 17 18))))))
(ert-deftest test-markdown-parsing/inline-code-at-point-no-space ()
"Test `markdown-inline-code-at-point' with multiple code spans in a row.."
(markdown-test-string "a`foo`b`bar`c`baz`d"
(goto-char 1) ; "a"
(should-not (markdown-inline-code-at-point-p))
(dolist (loc (number-sequence 2 7)) ; "`foo`b"
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 2 7 2 3 3 6 6 7))))
(dolist (loc (number-sequence 8 13)) ; "`bar`c"
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 8 13 8 9 9 12 12 13))))
(dolist (loc (number-sequence 14 19)) ; "`baz`d"
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 14 19 14 15 15 18 18 19))))))
(ert-deftest test-markdown-parsing/code-at-point-blank-line ()
"Test `markdown-inline-code-at-point-p' at beginning of block."
(markdown-test-string "----------\n\n## foo\n"
(should-not (markdown-inline-code-at-point-p))
(forward-line)
(should-not (markdown-inline-code-at-point-p))
(forward-line)
(should-not (markdown-inline-code-at-point-p))))
(ert-deftest test-markdown-parsing/in-comment-p-position ()
"Test `markdown-in-comment-p'."
(markdown-test-string
"HTML comment"
(should (eq (point) (point-min)))
(should-not (markdown-in-comment-p (point-max)))
(should (eq (point) (point-min)))))
(ert-deftest test-markdown-parsing/match-comments ()
"Test `markdown-match-comments'."
(markdown-test-string
"HTML comment"
(should (markdown-match-comments (point-max)))
(should (eq (point) 18))
(should (equal (match-data) (list 6 18)))
(should-not (markdown-match-comments (point-max)))))
(ert-deftest test-markdown-parsing/range-property-any ()
"Test behavior of `markdown-range-property-any'."
(markdown-test-file
"inline.text"
(should (markdown-range-property-any
(point-min) (point-at-eol)
'face '(markdown-markup-face markdown-italic-face)))
(should-not (markdown-range-property-any
(point-min) (point-at-eol)
'face '(markdown-bold-face)))))
(ert-deftest test-markdown-parsing/inline-code ()
"Don't cause infinite loop for inline code just after metadata block
Detail: https://github.com/jrblevin/markdown-mode/issues/115"
(markdown-test-string "---
x: x
---
`x`
"
(should (markdown-match-code (point-max)))
(should (= (point) 18))
(should (equal (match-data t) '(14 17 14 15 15 16 16 17)))
(should-not (markdown-match-code (point-max)))))
(ert-deftest test-markdown-parsing/list-item-at-point ()
"Test `markdown-list-item-at-point-p'."
(markdown-test-file "lists.text"
(let ((orig-match-data '(1 2 3 4))
(not-list-points '(273 399 512 3615))
(list-points '(1063 1063 1176 1283 1659 1830 1919 2150
2393 2484 2762 2853 3097 3188 3700
3903 4009)))
;; markdown-inline-code-at-point-p should not modify match data
(set-match-data orig-match-data)
;; Not list items
(dolist (pos not-list-points)
(goto-char pos)
(should-not (markdown-list-item-at-point-p))
(should (equal (match-data) orig-match-data)))
;; List items
(dolist (pos list-points)
(goto-char pos)
(should (markdown-list-item-at-point-p))
(should (equal (match-data) orig-match-data))))))
(ert-deftest test-markdown-parsing/heading-at-point ()
"Test `markdown-heading-at-point'."
(save-match-data
(markdown-test-file "outline.text"
(should-not (markdown-heading-at-point))
(markdown-test-goto-heading "An underline-style header")
(forward-line -1)
(should (markdown-heading-at-point))
(should (equal (match-data t) (get-text-property (point) 'markdown-heading)))
(should (equal (match-data t) (get-text-property (point) 'markdown-heading-1-setext))))))
(ert-deftest test-markdown-parsing/inline-link-in-code-block ()
"Test `markdown-match-generic-links'."
(markdown-test-string " **bold**
_italic_
[link](url)
* list"
(goto-char (point-min))
;; The link inside the pre block should not match.
(should-not (markdown-match-generic-links (point-max) nil))
;; Point should be left at limit.
(should (= (point) (point-max)))))
(ert-deftest test-markdown-parsing/broken-inline-link ()
"Test `markdown-match-generic-links' with an invalid link."
(markdown-test-string "[site1](http://site1.com
[site2](http://site2.com)
[site3](http://site3.com)"
(goto-char (point-min))
(let ((limit (point-at-eol)))
;; The first link is broken and shouldn't match.
(should-not (markdown-match-generic-links limit nil))
;; Subsequent search shouldn't match, so point should move to limit.
(should (= (point) limit)))
;; The second link should still match, starting from (point-min).
(let ((limit (point-at-eol 2)))
(should (markdown-match-generic-links limit nil))
(should (= (point) (match-end 0))))
;; The third link should match when starting past the second one.
(goto-char (match-end 0))
(should (markdown-match-generic-links (point-max) nil))
(should (= (point) (match-end 0)))))
(ert-deftest test-markdown-parsing/code-block-lang ()
"Test `markdown-code-block-lang'."
;; Test with GFM code blocks.
(markdown-test-file "GFM.md"
;; Test a call with the optional argument.
(should (string-equal
(markdown-code-block-lang
'(1455 . markdown-gfm-block-begin)) "js"))
;; Test a call without the optional argument.
(goto-char 1504) ;; middle of a GFM code block
(should (string-equal (markdown-code-block-lang) "js")))
;; Test with tilde-fenced cdoe blocks.
(markdown-test-file "outline-code.text"
(goto-char 107) ;; middle of a tilde fenced code block
(should (string-equal (markdown-code-block-lang
'(83 . markdown-tilde-fence-begin)) "bash"))))
(ert-deftest test-markdown-parsing/code-block-lang-period ()
"Test `markdown-code-block-lang' when language name begins with a period."
(markdown-test-string "~~~ { .ruby }
puts 'hello, world'
~~~
"
(should (string-equal (markdown-code-block-lang) "ruby"))))
;;; Reference Checking:
(ert-deftest test-markdown-references/goto-line-button ()
"Create and test a goto line button."
(markdown-test-string "line 1\nline 2\n"
;; Store the temporary buffer with the text
(let ((target (current-buffer)))
;; Create a new buffer for inserting
(with-temp-buffer
;; Verify that point is in a different buffer
(should (not (equal (current-buffer) target)))
;; Insert and press the button
(insert-button "goto line 2"
:type 'markdown-goto-line-button
'target-buffer target
'target-line 2)
(should (string-equal (buffer-string) "goto line 2"))
(backward-button 1)
(call-interactively 'push-button)
;; Verify that point is on line 2 of target buffer
(should (= (line-number-at-pos) 2))
(should (looking-at "line 2"))
(should (equal (current-buffer) target))))))
(ert-deftest test-markdown-references/button-map ()
"Verify that button-buffer-map is used for check references buffer."
(markdown-test-string "[undefined][ref]\n"
(let* ((target (buffer-name))
(check (format "*Undefined references for %s*" target)))
(markdown-check-refs)
(with-current-buffer (get-buffer check)
(should (equal (local-key-binding (kbd "TAB")) 'forward-button))
(should (equal (local-key-binding (kbd "")) 'backward-button))))))
;;; Lists:
(ert-deftest test-markdown-lists/nested-list-file ()
"Test list item propertization for a nested list."
(markdown-test-file "nested-list.text"
(let ((values '(((1 25 3 5 "- " nil))
((26 189 3 5 "- " nil))
((191 581 3 5 "- " nil))
((217 482 7 9 "- " nil)
(191 581 3 5 "- " nil))
((484 581 7 9 "- " nil)
(191 581 3 5 "- " nil))
((514 581 11 13 "- " nil)
(484 581 7 9 "- " nil)
(191 581 3 5 "- " nil)))))
(cl-loop
for value in values
do (should
(equal (mapcar #'butlast (get-text-property (point) 'markdown-list-item)) value))
(markdown-outline-next)))))
(ert-deftest test-markdown-lists/levels-1 ()
"Test list levels function `markdown-calculate-list-levels'."
(markdown-test-file "nested-list.text"
(let ((values '(((1 . 1) . nil) ((2 . 13) . (3)) ((14 . 23) . (7 3))
((24 . 26) . (11 7 3)))))
(cl-loop for (range . value) in values
do (goto-char (point-min))
(forward-line (1- (car range)))
(dotimes (n (- (cdr range) (car range)))
(should (equal (markdown-calculate-list-levels) value))
(forward-line))))))
(ert-deftest test-markdown-lists/levels-2 ()
"Test list levels function `markdown-calculate-list-levels'."
(markdown-test-file "syntax.text"
(let ((values '(((1 . 13) . nil) ((14 . 14) . (0)) ((15 . 17) . (4 0))
((18 . 18) . (0)) ((19 . 24) . (4 0)) ((25 . 25) . (0))
((26 . 29) . (4 0)) ((30 . 30) . (0)) ((31 . 33) . (4 0))
((34 . 588) . nil) ((589 . 595) . (0)) ((596 . 814) . nil)
((815 . 820) . (0)) ((821 . 898) . nil))))
(cl-loop for (range . value) in values
do (goto-char (point-min))
(forward-line (1- (car range)))
(dotimes (n (- (cdr range) (car range)))
(should (equal (markdown-calculate-list-levels) value))
(forward-line))))))
(ert-deftest test-markdown-lists/levels-interior ()
"Test `markdown-calculate-list-levels' from inside a list item."
(markdown-test-file "nested-list.text"
(goto-char 36)
(should (equal (markdown-calculate-list-levels) (list 3)))
(goto-char 267)
(should (equal (markdown-calculate-list-levels) (list 7 3)))
(goto-char 540)
(should (equal (markdown-calculate-list-levels) (list 11 7 3)))))
(ert-deftest test-markdown-lists/bounds-1 ()
"Test list item bounds function `markdown-cur-list-item-bounds'."
(markdown-test-file "lists.text"
(markdown-test-goto-heading "Case 9")
(forward-line)
(should (eq (point) 3699))
(markdown-next-list-item 4)
(should (eq (point) 3700))
(should (equal (butlast (markdown-cur-list-item-bounds))
(list 3700 3901 0 4 "- " nil)))
(markdown-next-list-item 4)
(should (eq (point) 3903))
(should (equal (butlast (markdown-cur-list-item-bounds))
(list 3903 3937 0 4 "* " nil)))))
(ert-deftest test-markdown-lists/bounds-2 ()
"Function `markdown-cur-list-item-bounds' should return nil outside of list items."
(markdown-test-string "line one\n\n* item\n"
(should (null (markdown-cur-list-item-bounds)))
(forward-line)
(should (null (markdown-cur-list-item-bounds)))
(forward-line)
(should (markdown-cur-list-item-bounds))))
(ert-deftest test-markdown-lists/bounds-prev ()
"Test list item bounds function `markdown-prev-list-item-bounds'."
(markdown-test-file "lists.text"
(markdown-test-goto-heading "Case 9")
(markdown-next-list-item 4)
(markdown-next-list-item 4)
(should (eq (point) 3903))
(should (equal (butlast (markdown-prev-list-item-bounds))
(list 3700 3901 0 4 "- " nil)))))
(ert-deftest test-markdown-lists/bounds-next ()
"Test list item bounds function `markdown-next-list-item-bounds'."
(markdown-test-file "lists.text"
(markdown-test-goto-heading "Case 2")
(goto-char 1283)
(should-not (markdown-next-list-item-bounds))
(markdown-test-goto-heading "Case 9")
(markdown-next-list-item 4)
(should (eq (point) 3700))
(should (equal (butlast (markdown-next-list-item-bounds))
(list 3903 3937 0 4 "* " nil)))))
(ert-deftest test-markdown-lists/bounds-gfm-task-list-item ()
"Test `markdown-cur-list-item-bounds' with a GFM task list item."
(markdown-test-string " - [ ] task name"
(should (equal (butlast (markdown-cur-list-item-bounds))
'(1 18 2 4 "- " "[ ] ")))))
(ert-deftest test-markdown-lists/gfm-task-list-item-at-point-1 ()
"Test `markdown-gfm-task-list-item-at-point' with regular list items."
(markdown-test-file "nested-list.text"
(dolist (pos '(1 26 36 267 514 540))
(goto-char pos)
(should-not (markdown-gfm-task-list-item-at-point)))))
(ert-deftest test-markdown-lists/gfm-task-list-item-at-point-2 ()
"Test `markdown-gfm-task-list-item-at-point' with a task list item."
(markdown-test-string " - [ ] task"
(should (markdown-gfm-task-list-item-at-point))))
(ert-deftest test-markdown-insertion/insert-gfm-task-list-item ()
"Test `markdown-insert-list-item' in a GFM task list."
(markdown-test-string " - [ ] task"
(goto-char (point-max))
(call-interactively 'markdown-insert-list-item)
(should (string-equal (buffer-string) " - [ ] task\n - [ ] "))))
(ert-deftest test-markdown-lists/promotion-and-demotion ()
"Test function `markdown-promote-list-item'."
(markdown-test-file "nested-list.text"
(forward-line)
(should (looking-at-p " - List level 1 item 2
Second paragraph of item 2
Nested pre block in item 2
Four spaces past the marker
Another paragraph of item 2"))
(markdown-demote-list-item)
(should (looking-at-p " - List level 1 item 2
Second paragraph of item 2
Nested pre block in item 2
Four spaces past the marker
Another paragraph of item 2"))
(markdown-promote-list-item)
(should (looking-at-p " - List level 1 item 2
Second paragraph of item 2
Nested pre block in item 2
Four spaces past the marker
Another paragraph of item 2"))
(goto-char (point-min))
(forward-line 22)
(should (looking-at-p " - List level 3 item 1
Nested pre block"))
(markdown-demote-list-item)
(should (looking-at-p " - List level 3 item 1
Nested pre block"))
(markdown-promote-list-item)
(should (looking-at-p " - List level 3 item 1
Nested pre block"))))
(ert-deftest test-markdown-lists/promotion-and-demotion-custom ()
"Test custom variable `markdown-list-indent-width'."
(markdown-test-file "nested-list.text"
(forward-line)
(should (looking-at " - List level 1 item 2
Second paragraph of item 2
Nested pre block in item 2
Four spaces past the marker
Another paragraph of item 2"))
(let ((markdown-list-indent-width 2))
(markdown-demote-list-item))
(should (looking-at " - List level 1 item 2
Second paragraph of item 2
Nested pre block in item 2
Four spaces past the marker
Another paragraph of item 2"))))
(ert-deftest test-markdown-lists/add-gfm-checkbox ()
(markdown-test-file "check-items.text"
(goto-char (point-min))
(end-of-line)
(should (markdown-insert-gfm-checkbox))
(should (= (line-number-at-pos (point)) 1))
(should (eolp))
(should (string-equal (buffer-substring-no-properties (line-beginning-position) (point))
" * [ ] "))
(forward-line 2)
(back-to-indentation)
(should (markdown-insert-gfm-checkbox))
(should (= (line-number-at-pos (point)) 3))
(should (string-equal (buffer-substring-no-properties (line-beginning-position) (point))
" * [ ] "))
(should (string-equal (buffer-substring-no-properties (point) (line-end-position))
"item1"))
(forward-line 2)
(back-to-indentation)
(forward-char 1)
(should (markdown-insert-gfm-checkbox))
(should (= (line-number-at-pos (point)) 5))
(should (string-equal (buffer-substring-no-properties (line-beginning-position) (point))
" * [ ] i"))
(should (string-equal (buffer-substring-no-properties (point) (line-end-position))
"tem2"))
(forward-line 2)
(back-to-indentation)
(forward-char 2)
(should (markdown-insert-gfm-checkbox))
(should (= (line-number-at-pos (point)) 7))
(should (string-equal (buffer-substring-no-properties (line-beginning-position) (point))
"- [ ] "))
(should (string-equal (buffer-substring-no-properties (point) (line-end-position))
"item3"))
(forward-line 2)
(back-to-indentation)
(forward-char 3)
(should (markdown-insert-gfm-checkbox))
(should (= (line-number-at-pos (point)) 9))
(should (string-equal (buffer-substring-no-properties (line-beginning-position) (point))
"- [ ] i"))
(should (string-equal (buffer-substring-no-properties (point) (line-end-position))
"tem4"))
(forward-line 2)
(end-of-line)
(should-not (markdown-insert-gfm-checkbox))
(should (= (line-number-at-pos (point)) 11))
(should (eolp))
(should (string-equal (buffer-substring-no-properties (line-beginning-position) (point))
"* [ ] item5"))
(forward-line 1)
(back-to-indentation)
(should (markdown-insert-gfm-checkbox))
(should (= (line-number-at-pos (point)) 12))
(should (eolp))
(should (string-equal (buffer-substring-no-properties
(line-beginning-position)
(point))
"* [ ] "))))
(ert-deftest test-markdown-lists/toggle-gfm-checkbox ()
(markdown-test-string " - [X] GFM task list item"
(should (string-equal (markdown-toggle-gfm-checkbox) "[ ]"))
(should (string-equal (buffer-string) " - [ ] GFM task list item"))
(should (string-equal (markdown-toggle-gfm-checkbox) "[x]"))
(should (string-equal (buffer-string) " - [x] GFM task list item"))))
(ert-deftest test-markdown-lists/beginning-of-list ()
"Test `markdown-beginning-of-list'."
(markdown-test-file "lists.text"
;; Case 1: not in a list
(goto-char 399)
(should-not (markdown-beginning-of-list))
(should (= (point) 399))
;; Case 2
(goto-char 1281)
(should (= (markdown-beginning-of-list) 1063))
(should (= (point) 1063))
(goto-char 1395)
(should (= (markdown-beginning-of-list) 1063))
(should (= (point) 1063))
;; Case 3
(goto-char 1848)
(should (= (markdown-beginning-of-list) 1659))
(should (= (point) 1659))
;; Case 4
(goto-char 2041)
(should (= (markdown-beginning-of-list) 1919))
(should (= (point) 1919))
;; Case 8
(goto-char 3553)
(should (= (markdown-beginning-of-list) 3096))
(should (= (point) 3096))))
(ert-deftest test-markdown-lists/end-of-list ()
"Test `markdown-end-of-list'."
(markdown-test-file "lists.text"
;; Case 1: not in a list
(goto-char 399)
(should-not (markdown-end-of-list))
(should (= (point) 399))
;; Case 2
(goto-char 1281)
(should (= (markdown-end-of-list) 1396))
(should (= (point) 1396))
(goto-char 1395)
(should (= (markdown-end-of-list) 1396))
(should (= (point) 1396))
;; Case 3
(goto-char 1659)
(should (= (markdown-end-of-list) 1849))
(should (= (point) 1849))
;; Case 4
(goto-char 2041)
(should (= (markdown-end-of-list) 2092))
(should (= (point) 2092))
;; Case 8
(goto-char 3553)
(should (= (markdown-end-of-list) 3614))
(should (= (point) 3614))))
(ert-deftest test-markdown-lists/up-list ()
"Test `markdown-up-list'."
(markdown-test-file "nested-list.text"
(goto-char 581)
(should (= (markdown-up-list) 484))
(should (= (point) 484))
(should (= (markdown-up-list) 191))
(should (= (point) 191))
;; Return nil upon failure, but move out of list.
(should-not (markdown-up-list))
(should (= (point) (point-min)))))
;;; Outline minor mode tests:
(ert-deftest test-markdown-outline/navigation ()
"Test outline navigation functions."
(markdown-test-file "outline.text"
;; Navigate to the first visible heading
(markdown-next-visible-heading 1)
(should (eq (point) 19))
(should (looking-at "^# A top-level header"))
;; Navigate forward at the same level
(markdown-forward-same-level 1)
(should (eq (point) 351))
(should (looking-at "^An underline-style header$"))
;; Navigate backward by four visible headings
(markdown-previous-visible-heading 4)
(should (eq (point) 69))
(should (looking-at "^## A second-level header$"))
;; Navigate up the hierarchy (atx)
(call-interactively #'markdown-up-heading)
(should (looking-at "^# A top-level header"))
(should (eq (mark) 69))
;; Navigate up the hierarchy (setext)
(goto-char 516)
(call-interactively #'markdown-up-heading)
(should (looking-at "^An underline-style header$"))
(should (eq (mark) 516))
;; Navigate back in the outline (setext to atx)
(forward-line) ;; move to setext underline
(markdown-backward-same-level 1)
(should (looking-at "^# A top-level header"))))
(ert-deftest test-markdown-outline/navigation-with-code ()
"Test outline navigation functions with code blocks."
(markdown-test-file "outline-code.text"
;; Navigate forward at the same level
(markdown-forward-same-level 1)
(should (eq (point) 159))
(should (looking-at "^# Level one again"))))
(ert-deftest test-markdown-outline/back-to-heading-over-code-block ()
"Test `markdown-back-to-heading-over-code-block' over."
(markdown-test-file "outline-code.text"
;; Initialize match data to known quantity.
(set-match-data '(1 2 3 4))
(should (equal (match-data t) '(1 2 3 4)))
;; Function should navigate back over code blocks.
(re-search-forward "^# In a code block")
(should (= (markdown-back-to-heading-over-code-block) 69))
;; Match data should be set for markdown-regex-header.
(should (equal (match-data t) (get-text-property (point) 'markdown-heading)))
;; Function should return t when at a heading.
(should (equal (markdown-back-to-heading-over-code-block) t))
;; Insert some text before the first heading.
(goto-char (point-min))
(save-excursion (insert "foo\n\n"))
;; Function should throw an error if no previous heading.
(should-error (markdown-back-to-heading-over-code-block))
;; Function should return nil without error if NO-ERROR is non-nil.
(should-not (markdown-back-to-heading-over-code-block t t))))
(ert-deftest test-markdown-outline/visibility-atx ()
"Test outline visibility cycling for ATX-style headers."
(markdown-test-file "outline.text"
(let (last-command this-command)
;; Navigate to the second visible heading
(markdown-next-visible-heading 2)
(should (eq (point) 69))
(should (looking-at "^## A second-level header$"))
;; Cycle visibility of this subtree
(setq this-command 'markdown-cycle)
(markdown-cycle)
(setq last-command 'markdown-cycle)
(should (eq (point) 69))
(should (looking-at "^## A second-level header$"))
;; Test that the entire subtree is invisible
(markdown-test-range-has-property 93 349 'invisible 'outline)
;; Cycle visibility of this subtree again
(markdown-cycle)
(should (eq (point) 69))
(should (looking-at "^## A second-level header$"))
;; Test that text is visible
(markdown-test-range-has-property 95 121 'invisible nil)
;; Test that subheadings are visible
(markdown-test-range-has-property 123 141 'invisible nil)
;; Cycle visibility of this subtree again
(markdown-cycle)
(should (eq (point) 69))
(should (looking-at "^## A second-level header$"))
;; Verify that entire subtree is visible
(markdown-test-range-has-property 93 349 'invisible nil))))
(ert-deftest test-markdown-outline/visibility-setext ()
"Test outline visibility cycling for setext-style headers."
(markdown-test-file "outline.text"
;; Navigate to the sixth visible heading
(markdown-next-visible-heading 7)
(markdown-previous-visible-heading 1)
(should (looking-at markdown-regex-header))
(should (string-equal (match-string-no-properties 1) "An underline-style header"))
(should (string-equal (match-string-no-properties 2) "========================="))
;; Cycle visibility subtree, test that it's invisible
(markdown-cycle)
(markdown-test-range-has-property 404 515 'invisible 'outline)
;; Cycle visibility subtree, test that text and headers are visible
(markdown-cycle)
(markdown-test-range-has-property 404 417 'invisible nil)
(markdown-test-range-has-property 420 451 'invisible nil)))
(ert-deftest test-markdown-outline/visibility-with-code ()
"Test outline visibility cycling with code blocks."
(markdown-test-file "outline-code.text"
(let (last-command this-command)
;; Cycle global visibility to "overview" mode
(setq this-command 'markdown-cycle)
(markdown-cycle t)
(setq last-command 'markdown-cycle)
(should (eq (point) (point-min)))
(should (looking-at "^# Level one"))
;; Test that the code block is invisible
(markdown-test-range-has-property 83 157 'invisible 'outline)
;; Check subsequent headings
(outline-next-visible-heading 1)
(should (eq (point) 69))
(should (looking-at "^## Level two"))
(outline-next-visible-heading 1)
(should (eq (point) 159))
(should (looking-at "^# Level one again")))))
(ert-deftest test-markdown-outline/visibility-with-metadata ()
"Test outline visibility cycling with metadata blocks."
(markdown-test-string
"---
layout = post
date = 2015-08-13 11:35:25 EST
---
"
(let (last-command this-command)
;; Cycle global visibility to "overview" mode
(setq this-command 'markdown-cycle)
(markdown-cycle t)
;; Check that text is visible
(markdown-test-range-has-property (point-min) (point-max) 'invisible nil))))
(ert-deftest test-markdown-outline/level ()
"Test `markdown-outline-level'."
(markdown-test-file "outline.text"
(markdown-next-heading)
(should (= (markdown-outline-level) 1))
(markdown-forward-same-level 1)
(should (= (markdown-outline-level) 1))
(markdown-next-heading)
(should (= (markdown-outline-level) 2))
(markdown-next-heading)
(should (= (markdown-outline-level) 1))
(markdown-next-heading)
(should (= (markdown-outline-level) 2))))
;;; Movement tests:
(ert-deftest test-markdown-movement/defun ()
"Test defun navigation."
(markdown-test-file "outline.text"
;; end-of-defun should go to point-max
(end-of-defun 10)
(should (= (point) (point-max)))
;; end-of-defun should stop just before the next header
(goto-char (point-min))
(end-of-defun)
(should (looking-at "\n# A top-level header"))
(end-of-defun)
(should (looking-at "\n## A second-level header"))
(end-of-defun)
(should (looking-at "\n### Third level ###"))
(end-of-defun)
(should (looking-at "\n### Third level number two ###"))
;; beginning-of-defun should move to the start of the previous header
(beginning-of-defun)
(should (looking-at "### Third level ###"))
(beginning-of-defun)
(should (looking-at "## A second-level header"))
(beginning-of-defun)
(should (looking-at "# A top-level header"))
(beginning-of-defun)
;; beginning-of-defun should move up to point-min
(should (= (point) (point-min)))
;; (beginning-of-defun -1) should move to the start of the next header
(forward-line 2)
(beginning-of-defun -1)
(should (looking-at "## A second-level header"))
(beginning-of-defun -1)
(should (looking-at "### Third level ###"))
(beginning-of-defun -1)
(should (looking-at "### Third level number two ###"))))
(ert-deftest test-markdown-movement/beginning-of-defun-at-point-max ()
"Test beginning of defun navigation at point-max."
(markdown-test-file "outline.text"
(goto-char (point-max))
(beginning-of-defun)))
(ert-deftest test-markdown-movement/text-block ()
"Test plain text block movement."
(markdown-test-file "outline.text"
(markdown-end-of-text-block)
(should (looking-at "\n# A top-level header"))
(markdown-end-of-text-block)
(should (looking-at "\nfollowed by some body text"))
(markdown-end-of-text-block)
(should (looking-at "\n## A second-level header"))
(markdown-end-of-text-block)
(should (looking-at "\nfollowed by some body text"))
(markdown-end-of-text-block)
(should (looking-at "\n### Third level ###"))
(markdown-end-of-text-block)
(should (looking-at "\n\\* A list item"))
(markdown-end-of-text-block)
(should (looking-at "\n### Third level number two ###"))
(markdown-end-of-text-block)
(should (looking-at "\n### Level two again"))
(markdown-end-of-text-block)
(should (looking-at "\nfollowed by some body text"))
(markdown-test-goto-heading "Level two")
(markdown-end-of-text-block)
(should (looking-at "\nbar"))
(markdown-end-of-text-block)
(should (= (point) (point-max)))
(markdown-beginning-of-text-block)
(should (looking-at "bar"))
(markdown-beginning-of-text-block)
(should (looking-at "## Level two"))
(markdown-beginning-of-text-block)
(should (looking-at "foo"))
(markdown-beginning-of-text-block)
(should (looking-at "# Level one"))
(markdown-beginning-of-text-block)
(should (looking-at "* With"))
(markdown-beginning-of-text-block)
(should (looking-at "And a level two underline header"))
(goto-char (point-min))
(markdown-test-goto-heading "A top-level header")
(beginning-of-line)
(markdown-beginning-of-text-block)
(should (= (point) (point-min)))))
(ert-deftest test-markdown-movement/mark-text-block ()
"Test `markdown-mark-text-block'."
(markdown-test-file "outline.text"
;; Start in middle of nested list with no separating whitespace.
(goto-char 193)
(markdown-mark-text-block)
(should (= (point) 143))
(should (= (mark) 269))))
(ert-deftest test-markdown-movement/paragraph ()
"Test Markdown paragraph movement."
(markdown-test-file "outline.text"
(markdown-forward-paragraph)
(should (looking-at "\n# A top-level header"))
(markdown-forward-paragraph)
(should (looking-at "\nfollowed by some body text"))
(markdown-forward-paragraph)
(should (looking-at "\n## A second-level header"))
(markdown-forward-paragraph)
(should (looking-at "\nfollowed by some body text"))
(markdown-forward-paragraph)
(should (looking-at "\n### Third level ###"))
(markdown-forward-paragraph)
(should (looking-at "\n\\* A list item"))
(markdown-forward-paragraph)
(should (looking-at "\\* and another"))
(markdown-forward-paragraph)
(should (looking-at " \\+ and a sublist"))
(markdown-forward-paragraph)
(should (looking-at "- And a third"))
(markdown-forward-paragraph)
(should (looking-at "\n### Third level number two ###"))
(markdown-forward-paragraph)
(should (looking-at "\n### Level two again"))
(markdown-forward-paragraph)
(should (looking-at "\nfollowed by some body text"))
(markdown-test-goto-heading "Level two")
(markdown-forward-paragraph)
(should (looking-at "\nbar"))
(markdown-forward-paragraph)
(should (= (point) (point-max)))
(markdown-backward-paragraph)
(should (looking-at "bar"))
(markdown-backward-paragraph)
(should (looking-at "## Level two"))
(markdown-backward-paragraph)
(should (looking-at "foo"))
(markdown-backward-paragraph)
(should (looking-at "# Level one"))
(markdown-backward-paragraph)
(should (looking-at "\\* List"))
(markdown-backward-paragraph)
(should (looking-at "\\* an unordered"))
(markdown-backward-paragraph)
(should (looking-at "\\* With"))
(markdown-backward-paragraph)
(should (looking-at "And a level two underline header"))
(goto-char (point-min))
(markdown-test-goto-heading "A top-level header")
(beginning-of-line)
(markdown-backward-paragraph)
(should (= (point) (point-min)))))
(ert-deftest test-markdown-movement/forward-paragraph-with-whitespace ()
"Test Markdown paragraph movement."
(markdown-test-file "blocks.md"
(markdown-test-goto-heading "With Whitespace")
(dolist (pos '(58 67 78 94 109 114 123 131 135 147 157 170 184 199))
(markdown-forward-paragraph)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/backward-paragraph-with-whitespace ()
"Test Markdown paragraph movement."
(markdown-test-file "blocks.md"
(markdown-test-goto-heading "With Whitespace")
(markdown-next-heading)
(should (= (point) 200))
(dolist (pos '(185 172 158 148 136 132 124 115 110 94 78 67 59))
(markdown-backward-paragraph)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/forward-paragraph-without-whitespace ()
"Test Markdown paragraph movement."
(markdown-test-file "blocks.md"
(markdown-test-goto-heading "Without Whitespace")
(dolist (pos '(222 230 240 255 270 275 283 291 294 305 314 326 340 354))
(markdown-forward-paragraph)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/backward-paragraph-without-whitespace ()
"Test Markdown paragraph movement."
(markdown-test-file "blocks.md"
(goto-char (point-max))
(dolist (pos '(340 328 314 305 294 291 284 275 271 255 240 230 223 200))
(markdown-backward-paragraph)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/block ()
"Test Markdown block movement."
(markdown-test-file "outline.text"
(markdown-forward-block)
(should (looking-at "\n# A top-level header"))
(markdown-forward-block)
(should (looking-at "\nfollowed by some body text"))
(markdown-forward-block)
(should (looking-at "\n## A second-level header"))
(markdown-forward-block)
(should (looking-at "\nfollowed by some body text"))
(markdown-forward-block)
(should (looking-at "\n### Third level ###"))
(markdown-forward-block)
(should (looking-at "\n\\* A list item"))
(markdown-forward-block)
(should (looking-at "\n### Third level number two ###"))
(markdown-forward-block)
(should (looking-at "\n### Level two again"))
(markdown-forward-block)
(should (looking-at "\nfollowed by some body text"))
(markdown-test-goto-heading "Level two")
(markdown-forward-block)
(should (looking-at "\nbar"))
(markdown-forward-block)
(should (= (point) (point-max)))
(markdown-backward-block)
(should (looking-at "bar"))
(markdown-backward-block)
(should (looking-at "## Level two"))
(markdown-backward-block)
(should (looking-at "foo"))
(markdown-backward-block)
(should (looking-at "# Level one"))
(markdown-backward-block)
(should (looking-at "\\* With"))
(markdown-backward-block)
(should (looking-at "And a level two underline header"))
(goto-char (point-min))
(markdown-test-goto-heading "A top-level header")
(beginning-of-line)
(markdown-backward-block)
(should (= (point) (point-min)))))
(ert-deftest test-markdown-movement/forward-block-with-whitespace ()
"Test Markdown block movement."
(markdown-test-file "blocks.md"
(markdown-test-goto-heading "With Whitespace")
(dolist (pos '(58 109 114 131 135 147 157 184 199))
(markdown-forward-block)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/backward-block-with-whitespace ()
"Test Markdown block movement."
(markdown-test-file "blocks.md"
(markdown-test-goto-heading "With Whitespace")
(markdown-next-heading)
(dolist (pos '(185 158 148 136 132 115 110 59))
(markdown-backward-block)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/forward-block-without-whitespace ()
"Test Markdown block movement."
(markdown-test-file "blocks.md"
(markdown-test-goto-heading "Without Whitespace")
(dolist (pos '(222 270 275 291 294 305 314 340 354))
(markdown-forward-block)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/backward-block-without-whitespace ()
"Test Markdown block movement."
(markdown-test-file "blocks.md"
(goto-char (point-max))
(dolist (pos '(340 314 305 294 291 275 271 223 200))
(markdown-backward-block)
(should (= (point) pos)))))
(ert-deftest test-markdown-movement/page ()
"Test Markdown page movement."
(markdown-test-file "outline.text"
(markdown-forward-page)
(should (looking-at "# A top-level header"))
(markdown-forward-page)
(should (looking-at "An underline-style header"))
(markdown-forward-page)
(should (looking-at "# Level one"))
(markdown-forward-page)
(should (eobp))
(markdown-backward-page)
(should (looking-at "# Level one"))
(markdown-backward-page)
(should (looking-at "An underline-style header"))
(markdown-backward-page)
(should (looking-at "# A top-level header"))
(markdown-backward-page)
(should (bobp))))
(ert-deftest test-markdown-movement/blockquote-paragraphs ()
"Test filling of blockquotes containing multiple paragraphs."
(markdown-test-string "> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n>\n> Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n"
(forward-paragraph)
(should (looking-at "^>$"))
(should (= (point) 128))
(forward-paragraph)
(should (= (point) (point-max)))))
(ert-deftest test-markdown-movement/reference-definition ()
"Test jumping to reference definitions."
;; Jumping to explicit reference definition
(markdown-test-string "[a][ref]\n\n[ref]: gopher://localhost/\n"
(markdown-reference-goto-definition)
(should (= (point) 18)))
;; Jumping to implicit reference definition
(markdown-test-string "[a][]\n\n[a]: ftp://localhost/\n"
(markdown-reference-goto-definition)
(should (= (point) 13)))
;; Creating non-existent reference definition
(markdown-test-string "[a][]\n"
(markdown-reference-goto-definition)
(should (= (point) 13))
(should (string-equal (buffer-string) "[a][]\n\n[a]: \n"))))
(ert-deftest test-markdown-movement/back-to-same-level-over-code-block ()
"`markdown-backward-same-level' over code block which contains header
like statement. Detail: https://github.com/jrblevin/markdown-mode/issues/75"
(markdown-test-string "
## Header 2-1
## Header 2-2
```R
# Header Like Statement
```
## Header 2-3
"
(search-forward "## Header 2-3")
(let ((last-header-pos (point)))
(forward-line -1)
(call-interactively #'markdown-backward-same-level)
(should (looking-at-p "## Header 2-1"))
(goto-char last-header-pos)
(call-interactively #'markdown-backward-same-level)
(should (looking-at-p "## Header 2-2"))
(goto-char last-header-pos)
(markdown-backward-same-level 2)
(should (looking-at-p "## Header 2-1"))
(search-forward "# Header Like Statement")
(call-interactively #'markdown-backward-same-level)
(should (looking-at-p "## Header 2-1")))))
;;; Link tests:
(ert-deftest test-markdown-link/follow ()
"Test link following in a browser and in Emacs."
(markdown-test-string "[text](http://path?query=foo#id)"
(let* ((opened-url nil)
(browse-url-browser-function
(lambda (url &rest args) (setq opened-url url))))
(markdown-follow-thing-at-point nil)
(should (equal opened-url "http://path?query=foo#id"))))
(when (featurep 'url-parse)
(markdown-test-string "[text](path?query=foo#id)"
(markdown-follow-thing-at-point nil)
(should (equal (file-name-nondirectory (buffer-file-name)) "path"))
(kill-buffer))))
(ert-deftest test-markdown-link/inline-link-at-pos ()
"Test `markdown-link-at-pos' return values with an inline link."
(markdown-test-string "[text](url \"title\")"
(should (equal (markdown-link-at-pos (point)) '(1 20 "text" "url" nil "title" nil)))))
(ert-deftest test-markdown-link/inline-image-at-pos ()
"Test `markdown-link-at-pos' return values with an inline image."
(markdown-test-string "![text](url \"title\")"
(should (equal (markdown-link-at-pos (point)) '(1 21 "text" "url" nil "title" "!")))))
(ert-deftest test-markdown-link/reference-link-at-pos ()
"Test `markdown-link-at-pos' return values with a reference link."
(markdown-test-string "[text][ref]"
(should (equal (markdown-link-at-pos (point)) '(1 12 "text" nil "ref" nil nil)))))
(ert-deftest test-markdown-link/reference-image-at-pos ()
"Test `markdown-link-at-pos' return values with a reference image."
(markdown-test-string "![text][ref]"
(should (equal (markdown-link-at-pos (point)) '(1 13 "text" nil "ref" nil "!")))))
(ert-deftest test-markdown-link/angle-uri-at-pos ()
"Test `markdown-link-at-pos' return values with an angle bracket inline link."
(markdown-test-string ". To fix
;; this, we run the entire test in a new subdirectory of
;; `temporary-file-directory', which is guaranteed to not contain
;; any inaccessible directories.
(let ((temporary-file-directory
(file-name-as-directory (make-temp-file "markdown-test" :dir-flag))))
(markdown-test-temp-file "wiki-links.text"
(let* ((fn (concat (file-name-directory buffer-file-name)
"inline.text"))
(markdown-enable-wiki-links t))
;; Create inline.text in the same temp directory, refontify
(write-region "" nil fn nil 1)
(markdown-fontify-buffer-wiki-links)
;; Confirm location of first wiki link
(should (eq (markdown-next-link) 8))
;; First wiki link doesn't have a corresponding file
(markdown-test-range-has-property 8 20 'font-lock-face 'markdown-missing-link-face)
;; Second wiki link doesn't have a corresponding file
(should (eq (markdown-next-link) 73))
(markdown-test-range-has-property 73 88 'font-lock-face 'markdown-missing-link-face)
;; Move to third wiki link, and create the missing file
(should (eq (markdown-next-link) 155))
(should (string-equal (markdown-wiki-link-link) "inline"))
(markdown-test-range-has-property 155 164 'font-lock-face 'markdown-link-face)
;; Check wiki links in code blocks
(markdown-test-range-has-face 360 395 'markdown-pre-face)
;; Remove temporary files
(delete-file fn)))
(delete-directory temporary-file-directory)))
(ert-deftest test-markdown-wiki-link/kill ()
"Simple tests for `markdown-kill-thing-at-point' for wiki links."
(let ((kill-ring nil)
(markdown-enable-wiki-links t)
(tests (list '("[[foo]]" . "foo")
'("[[foo|bar]]" . "bar"))))
(dolist (test tests)
;; Load test string (the car), move to end of first line, kill
;; thing at point, and then verify that the kill ring contains cdr.
(markdown-test-string (car test)
(end-of-line)
(call-interactively 'markdown-kill-thing-at-point)
(should (string-equal (current-kill 0) (cdr test)))))))
;;; Filling tests:
(ert-deftest test-markdown-filling/blockquote ()
"Test filling of blockquotes.
See `adaptive-fill-first-line-regexp'."
(markdown-test-string "> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
(fill-paragraph)
(should (string-equal (buffer-string) "> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do\n> eiusmod tempor incididunt ut labore et dolore magna aliqua."))))
(ert-deftest test-markdown-filling/blockquote-paragraphs ()
"Test filling of blockquotes containing multiple paragraphs."
(markdown-test-string "> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n>\n> Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.\n"
(forward-paragraph)
(fill-paragraph)
(should (string-equal (buffer-string) "> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n>\n> Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris\n> nisi ut aliquip ex ea commodo consequat.\n"))))
(ert-deftest test-markdown-filling/leanpub-block ()
"Test adaptive filling of Leanpub blocks."
(markdown-test-string "A> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
(fill-paragraph)
(should (string-equal (buffer-string) "A> Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do\nA> eiusmod tempor incididunt ut labore et dolore magna aliqua."))))
(ert-deftest test-markdown-filling/space-after-list-marker ()
"`fill-paragraph' should preserve more than one space after a list marker,
since users may wish to indent their lists more than one space more than the
width of the marker. The examples on the Markdown Syntax page have three
spaces after the list marker for a total indentation of four."
(let ((str "\n\n* List item indented four spaces.\n* Also four spaces."))
(markdown-test-string str
(forward-line 2)
(fill-paragraph)
(should (string-equal (buffer-string) str)))))
(ert-deftest test-markdown-filling/multi-line-list-with-more-space ()
"`fill-paragraph' should preserve more than one space after a list marker
(see `test-preserve-space-after-list-marker')."
(let ((str "* This list item is continued on\n the next line"))
(markdown-test-string str
;; The first line is exactly 35 columns
(let ((fill-column 35))
(fill-paragraph)
(should (string-equal (buffer-string) str))))))
(ert-deftest test-markdown-filling/definition-list-add-leading-spaces ()
"`fill-paragraph' should adapt to spaces after list marker."
(markdown-test-string
": This list item is continued on the next line"
(let ((fill-column 35))
(fill-paragraph)
(should (string-equal
(buffer-string)
": This list item is continued on\n the next line")))))
(ert-deftest test-markdown-filling/definition-list-preserve-leading-spaces ()
"`fill-paragraph' should preserve spaces after list marker."
(let ((str ": This list item is continued on\n the next line")
(fill-column 35))
(markdown-test-string
str (fill-paragraph)
(should (string-equal (buffer-string) str)))))
(ert-deftest test-markdown-filling/list-item-plus ()
"Test filling of list items with plus sign markers.
See `adaptive-fill-regexp'."
(markdown-test-string " + Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
(fill-paragraph)
(should (string-equal (buffer-string) " + Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do\n eiusmod tempor incididunt ut labore et dolore magna aliqua."))))
(ert-deftest test-markdown-filling/list-item-plus-in-blockquote ()
"Test filling of list items with plus sign markers inside blockquote.
See `adaptive-fill-regexp'."
(markdown-test-string "> + Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
(fill-paragraph)
(should (string-equal (buffer-string) "> + Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do\n> eiusmod tempor incididunt ut labore et dolore magna aliqua."))))
(ert-deftest test-markdown-filling/line-break ()
"Test filling of paragraphs with hard line breaks.
See `paragraph-separate'."
(markdown-test-string "Lorem ipsum dolor sit amet, \nconsectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
(let ((fill-column 70))
(fill-paragraph)
(should (string-equal (buffer-string) "Lorem ipsum dolor sit amet, \nconsectetur adipisicing elit, sed do eiusmod tempor incididunt ut\nlabore et dolore magna aliqua.")))))
(ert-deftest test-markdown-filling/decimal-number-at-beginning ()
"Test filling when a number with a decimal appears at the beginning of a line."
(markdown-test-string "The circumference of a circle divided by it's radius is around\n3.14."
(fill-paragraph)
(should (string-equal (buffer-string) "The circumference of a circle divided by it's radius is around 3.14."))))
(ert-deftest test-markdown-filling/avoid-unintended-list-item ()
"Avoid breaking lines where it would result in an unintended list item."
(markdown-test-string "Lorem ipsum dolor sit 4. amet"
(let ((fill-column 22))
(fill-paragraph)
(should (string-equal (buffer-string) "Lorem ipsum dolor\nsit 4. amet")))))
(ert-deftest test-markdown-filling/no-break-link-reference ()
"Shouldn't break line between label and url, or combine two link references."
(let ((str "[label1]: http://long-url.example.com\n[label2]: http://another-long-url.example.com/"))
(markdown-test-string str
(let ((fill-column 15)) ; after end of label, before end of URL
(fill-paragraph)
(should (string-equal (buffer-string) str))))))
(ert-deftest test-markdown-filling/no-break-before-list-item ()
"There's no point in putting the first item of a list on the next line,
indented the same amount."
(let ((str "* [Link](http://way-too-long.example.com)\n"))
(markdown-test-string str
(auto-fill-mode 1)
(let ((fill-column 10))
(end-of-line)
(funcall auto-fill-function)
;; This test was known to fail in Emacs 25 and earlier.
(if (version< emacs-version "26.0")
(should-not (string-equal (buffer-string) str))
(should (string-equal (buffer-string) str)))))))
(ert-deftest test-markdown-filling/break-within-list-item ()
"This doesn't suppress auto-fill within a multi-word list item."
:expected-result :failed
(markdown-test-string "* [Link](http://example.com/) more text"
(auto-fill-mode 1)
(let ((fill-column 10))
(end-of-line)
(funcall auto-fill-function)
(should (string-equal
(buffer-string)
"* [Link](http://example.com/)\n more text")))))
(ert-deftest test-markdown-filling/preserve-next-line-footnote ()
"Footnote block can be after label"
(let ((str "[^label1]:\n Footnote block\n more footnote")) ; six spaces
(markdown-test-string str
(let ((fill-column 20)) ; could fit "footnote" after label, but shouldn't
(fill-paragraph)
(should (string-equal (buffer-string) str))))))
(ert-deftest test-markdown-filling/wrap-same-line-footnote ()
"Additional lines must be indented one level (four spaces) when wrapped."
(markdown-test-string "[^label]: Long line should be wrapped"
(let ((fill-column 25)) ; wrap before end of "should"
(fill-paragraph)
(should (string-equal (buffer-string) "[^label]: Long line\n should be wrapped")))))
(ert-deftest test-markdown-filling/wrap-extra-hanging-indentation ()
"Additional lines must be indented one level (four spaces) when wrapped."
(markdown-test-string "[^label]: Long line\n should be wrapped"
(let ((fill-column 25)) ; wrap before end of "should"
(fill-paragraph)
(should (string-equal (buffer-string) "[^label]: Long line\n should be wrapped")))))
(ert-deftest test-markdown-filling/full-justification ()
"Test paragraph detection with lines with lots of whitespace."
(markdown-test-string "Lorem Ipsum Lorem Ipsum Lorem Ipsum Lorem Ipsum Lorem Ipsum Lorem Dolor Sit Amet Consectetur http://very-long-url.lorem.ipsum.sic.dolor.sit.amet.com"
(setq default-justification 'full)
(fill-paragraph)
(should (string-equal (buffer-string) "Lorem Ipsum Lorem Ipsum Lorem Ipsum Lorem Ipsum Lorem Ipsum Lorem\nDolor Sit Amet Consectetur\nhttp://very-long-url.lorem.ipsum.sic.dolor.sit.amet.com"))
(backward-paragraph)
(forward-paragraph)
(should (= (point) 198))))
(ert-deftest test-markdown-filling/list-line ()
"Test fill-paragraph for list line. Don't insert bullet automatically.
Detail: https://github.com/jrblevin/markdown-mode/issues/79"
(markdown-test-string "* foo foo *foo* foo foo foo foo foo foo"
(let ((fill-column 10))
(fill-paragraph)
(fill-paragraph)
(forward-line 2)
(back-to-indentation)
(should-not (looking-at-p "\\*foo"))
(forward-line 1)
(back-to-indentation)
(should-not (looking-at-p "\\*foo")))))
(ert-deftest test-markdown-filling/ignore-header ()
"# Test fill-paragraph for containing header line paragraph.
https://github.com/jrblevin/markdown-mode/issues/159"
(markdown-test-string "# this is header line
this is not header line
"
(let ((fill-column 10))
(fill-paragraph)
(should (string= (buffer-substring (point) (line-end-position)) "# this is header line")))))
(ert-deftest test-markdown-filling/unclosed-square-bracket ()
"Test fill-paragraph following an unclosed square bracket."
(markdown-test-string "```\n[3\n```\n\naaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbb"
(let ((fill-column 20))
(forward-line 4)
(fill-paragraph)
(should (looking-at "aaaaaaaaaaaaaaaa\nbbbbbbbbbbbbbbbb")))))
(ert-deftest test-markdown-filling/skip-code-blocks ()
"Test `markdown-fill-paragraph' on code blocks."
(let ((text "test\n\n```\nhello\nworld\n```"))
(markdown-test-string text
(dotimes (n 5)
;; Fill at each line; buffer should not change.
(fill-paragraph)
(should (string-equal (buffer-string) text))))))
(ert-deftest test-markdown-filling/fill-region-skip-code-blocks ()
"Test `fill-region' on code blocks."
(let ((text "testing\n\n```\nhello\nworld\n```\n\n123"))
(markdown-test-string text
;; Fill entire buffer; buffer should not change.
(fill-region (point-min) (point-max))
(should (string-equal (buffer-string) text)))))
(ert-deftest test-markdown-filling/fill-region-skip-code-blocks-2 ()
"Test `fill-region' on a buffer with a code block with long paragraphs."
(markdown-test-string "long unwrapped paragraph 1
```
code
block
foo
bar
```
long unwrapped paragraph 2"
;; Test markdown-fill-forward-paragraph movement.
(should (= (markdown-fill-forward-paragraph 1) 0))
(should (= (point) 28)) ;; Point just after par. 1.
(should (= (markdown-fill-forward-paragraph 1) 0))
(should (= (point) 84)) ;; Point at end of par. 2.
;; Test filling the entire buffer with `fill-region'.
(let ((fill-column 12))
(fill-region (point-min) (point-max))
(should (string-equal (buffer-string)
"long
unwrapped
paragraph 1
```
code
block
foo
bar
```
long
unwrapped
paragraph 2")))))
(ert-deftest test-markdown-filling/fill-region-skip-code-blocks-3 ()
"Test `fill-region' on a lone code block with no surrounding text."
(let ((text "```\ncode\nblock\n```\n"))
(markdown-test-string text
;; Fill entire buffer; buffer should not change.
(fill-region (point-min) (point-max))
(should (string-equal (buffer-string) text)))))
(ert-deftest test-markdown-filling/long-paragraph-with-link ()
"Test `fill-paragraph' on a long paragraph with a long link.
See GH-173."
(markdown-test-string
"aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa [aaa aaa aaa aaa](aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) aaa aaa aaa aaa aaa."
(let ((fill-column 79)) (fill-paragraph))
(should (string-equal (buffer-string) "aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa
aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa aaa [aaa aaa aaa
aaa](aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) aaa aaa aaa aaa aaa."))))
(ert-deftest test-markdown-filling/pandoc-line-blocks ()
"Filling should leave Pandoc line blocks undisturbed.
This includes preserving whitespace after the pipe."
(let ((text "| The limerick packs laughs anatomical
| In space that is quite economical.
| But the good ones I've seen
| So seldom are clean
| And the clean ones so seldom are comical
| 200 Main St.
| Berkeley, CA 94718"))
(markdown-test-string text
(fill-region (point-min) (point-max))
(should (string-equal (buffer-string) text)))))
;;; Export tests:
(ert-deftest test-markdown-hook/xhtml-standalone ()
"Test `markdown-xhtml-standalone-regexp' and `markdown-output-standalone-p'."
(should (string-match markdown-xhtml-standalone-regexp
""))
(should (string-match markdown-xhtml-standalone-regexp
""))
(should (string-match markdown-xhtml-standalone-regexp
""))
(should-not (string-match markdown-xhtml-standalone-regexp
"title
"))
(should-not (string-match markdown-xhtml-standalone-regexp
"")))
(ert-deftest test-markdown-export/kill-buffer-nil ()
"Test `markdown-export-kill-buffer' equal to nil."
(markdown-test-temp-file "inline.text"
(let* ((markdown-export-kill-buffer nil)
(export-file (markdown-export))
(export-buffer (get-file-buffer export-file)))
;; Output buffer should remain open.
(should (member export-buffer (buffer-list))))))
(ert-deftest test-markdown-export/kill-buffer-t ()
"Test `markdown-export-kill-buffer' equal to t."
(markdown-test-temp-file "inline.text"
(let* ((markdown-export-kill-buffer t)
(export-file (markdown-export))
(export-buffer (get-file-buffer export-file)))
;; Output buffer should be killed.
(should-not export-buffer))))
;;; Hook tests:
(ert-deftest test-markdown-hook/before-export ()
"Test hook run before export XHTML."
(markdown-test-temp-file "lists.text"
(let* ((before-hook-run nil)
(orig-point (point))
(func (lambda ()
;; Change value of a variable
(setq before-hook-run t)
;; Insert some text
(goto-char (point-min))
(insert "#")
;; Deliberately move the point
(end-of-line)
;; Verify changes
(should (looking-back "^## List Cases" nil))
(should-not (= (point) orig-point))))
(ofile (progn
;; Register hook
(add-hook 'markdown-before-export-hook func)
;; Export XHTML and return filename
(markdown-export)))
(obuffer (get-file-buffer ofile)))
;; Test side effects of hook
(should (eq before-hook-run t))
;; Test position of point
(should (= (point) orig-point))
;; Test that buffer was restored to original state
(goto-char (point-min))
(should (looking-at "^# List Cases"))
;; Clean
(remove-hook 'markdown-before-export-hook func)
(kill-buffer obuffer)
(delete-file ofile))))
(ert-deftest test-markdown-hook/after-export ()
"Test hook run after export XHTML."
(markdown-test-temp-file "lists.text"
(let* ((after-hook-run nil)
(markdown-export-kill-buffer nil)
(func (lambda ()
;; Change variable value
(setq after-hook-run t)
;; Add comment to output buffer
(goto-char (point-min))
(insert "\n")))
(ofile (progn
;; Register hook
(add-hook 'markdown-after-export-hook func)
;; Export XHTML and return filename
(markdown-export)))
(obuffer (get-file-buffer ofile)))
(message "obuffer = %S" obuffer)
;; Test that variable was changed
(should (eq after-hook-run t))
;; Test that output buffer remains open
(should (get-buffer obuffer))
;; Test that output buffer modification remains
(with-current-buffer obuffer
(goto-char (point-min))
(should (looking-at "\n")))
;; Test that buffer modification was saved
(should-not (buffer-modified-p obuffer))
;; Clean up
(remove-hook 'markdown-after-export-hook func)
(kill-buffer obuffer)
(delete-file ofile))))
;;; Extension: math support
(ert-deftest test-markdown-math/file-local-variable ()
"Test enabling math mode via `hack-local-variables-hook'."
(markdown-test-file "math.text"
(should-not markdown-enable-math)
(hack-local-variables)
(should markdown-enable-math)))
(ert-deftest test-markdown-math/reload ()
"Test enabling math mode via variable `markdown-enable-math'."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
;; Flag should be set to t
(should markdown-enable-math)
;; Font-lock keywords should be updated.
(should (member (car markdown-mode-font-lock-keywords-math)
(cadr font-lock-keywords))))))
(ert-deftest test-markdown-math/preserve-user-keywords ()
"Test preserving user-specified font-lock keywords."
(let ((user-keyword '("\\<\\(FIXME\\):" 1 font-lock-warning-face t)))
;; Add user font-lock keyword using `font-lock-add-keywords'.
(font-lock-add-keywords 'markdown-mode (list user-keyword))
;; Visit a file using `markdown-mode'.
(markdown-test-file "math.text"
;; User keyword should be present initially.
(should (member user-keyword (cadr font-lock-keywords)))
;; User keyword should persist after calling `markdown-reload-extensions'.
(markdown-reload-extensions)
(should (member user-keyword (cadr font-lock-keywords))))
;; Remove the user keyword using `font-lock-remove-keywords'.
(font-lock-remove-keywords 'markdown-mode (list user-keyword))
;; Visit a file using `markdown-mode'.
(markdown-test-file "inline.text"
;; User keyword should not be present after removal.
(should-not (member user-keyword (cadr font-lock-keywords))))))
(ert-deftest test-markdown-math/preserve-local-user-keywords ()
"Test preserving buffer-specific user-specified font-lock keywords."
(let ((user-keyword '("\\<\\(FIXME\\):" 1 font-lock-warning-face t)))
;; Visit a file using `markdown-mode'.
(markdown-test-file "math.text"
;; Add user font-lock keyword using `font-lock-add-keywords'.
(font-lock-add-keywords nil (list user-keyword))
;; User keyword should be present initially.
(should (member user-keyword (cadr font-lock-keywords)))
;; User keyword should persist after calling `markdown-reload-extensions'.
(markdown-reload-extensions)
(should (member user-keyword (cadr font-lock-keywords)))
;; Remove the user keyword using `font-lock-remove-keywords'.
(font-lock-remove-keywords nil (list user-keyword))
;; User keyword should not be present after removal.
(should-not (member user-keyword (cadr font-lock-keywords))))))
(ert-deftest test-markdown-math/font-lock ()
"Test markdown math mode."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 1 32 nil)
(markdown-test-range-has-face 33 33 'markdown-markup-face)
(markdown-test-range-has-face 34 45 'markdown-math-face)
(markdown-test-range-has-face 46 46 'markdown-markup-face)
(markdown-test-range-has-face 47 49 nil)
(markdown-test-range-has-face 50 51 'markdown-markup-face)
(markdown-test-range-has-face 52 63 'markdown-math-face)
(markdown-test-range-has-face 64 65 'markdown-markup-face)
(markdown-test-range-has-face 66 98 nil)
(markdown-test-range-has-face 99 100 'markdown-markup-face)
(markdown-test-range-has-face 101 112 'markdown-math-face)
(markdown-test-range-has-face 113 114 'markdown-markup-face)
(markdown-test-range-has-face 113 114 'markdown-markup-face)
(markdown-test-range-has-face 117 117 'markdown-header-delimiter-face)
(markdown-test-range-has-face 119 152 'markdown-header-face-1)
(markdown-test-range-has-face 129 129 'markdown-markup-face)
(markdown-test-range-has-face 136 136 'markdown-markup-face)
(markdown-test-range-has-face 174 177 'markdown-markup-face)
(markdown-test-range-has-face 179 179 'markdown-markup-face)
(markdown-test-range-has-face 180 187 'markdown-language-keyword-face)
(markdown-test-range-has-face 188 188 'markdown-markup-face)
(markdown-test-range-has-face 190 210 'markdown-pre-face)
(markdown-test-range-has-face 212 215 'markdown-markup-face)
(markdown-test-range-has-face 218 218 'markdown-markup-face)
(markdown-test-range-has-face 219 223 'markdown-math-face)
(markdown-test-range-has-face 224 224 'markdown-markup-face)
(markdown-test-range-has-face 350 351 'markdown-markup-face)
(markdown-test-range-has-face 352 356 'markdown-math-face)
(markdown-test-range-has-face 357 358 'markdown-markup-face)
(markdown-test-range-has-face 359 391 nil)
(markdown-test-range-has-face 392 393 'markdown-markup-face)
(markdown-test-range-has-face 394 398 'markdown-math-face)
(markdown-test-range-has-face 399 400 'markdown-markup-face))))
(ert-deftest test-markdown-math/double-slash-display-math ()
"Test double slash display math font lock."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 403 474 nil)
(markdown-test-range-has-face 475 477 'markdown-markup-face)
(markdown-test-range-has-face 478 543 'markdown-math-face)
(markdown-test-range-has-face 544 546 'markdown-markup-face))))
(ert-deftest test-markdown-math/indented-double-slash-display-math ()
"Test font lock for indented double slash display math.
See GH-288."
(let ((markdown-enable-math t))
(markdown-test-string "- Einstein's equation:
\\\\[ E = m c^2 \\\\]"
(markdown-test-range-has-face 29 31 'markdown-markup-face)
(markdown-test-range-has-face 32 42 'markdown-math-face)
(markdown-test-range-has-face 43 45 'markdown-markup-face))))
(ert-deftest test-markdown-math/font-lock-italics ()
"Test markdown math mode with underscores."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 227 227 'markdown-markup-face)
(markdown-test-range-has-face 228 233 'markdown-math-face)
(markdown-test-range-has-face 234 234 'markdown-markup-face)
(markdown-test-range-has-face 235 270 nil)
(markdown-test-range-has-face 271 271 'markdown-markup-face)
(markdown-test-range-has-face 272 274 'markdown-math-face)
(markdown-test-range-has-face 275 275 'markdown-markup-face))))
(ert-deftest test-markdown-math/font-lock-no-bold ()
"Bold markers in math should not trigger bold."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 279 299 'markdown-math-face)
(markdown-test-range-has-face 301 308 nil)
(markdown-test-range-has-face 310 312 'markdown-math-face))))
;;; Extension: pipe table editing
(ert-deftest test-markdown-table/table-begin-top-of-file ()
"Test beginning of table detection at top of file."
(markdown-test-string "\n| 1 | 2 |\n"
(should-not (markdown-table-at-point-p))
(forward-line)
(should (markdown-table-at-point-p))
(should (= (markdown-table-begin) 2))))
;;; gfm-mode tests:
(ert-deftest test-markdown-gfm/pre-1 ()
"GFM pre block font lock test."
(markdown-test-file-gfm "gfm.text"
(markdown-test-range-has-face 2626 2637 nil)
(markdown-test-range-has-face 2639 2641 'markdown-markup-face)
(markdown-test-range-has-face 2642 2645 'markdown-language-keyword-face)
(markdown-test-range-has-face 2647 2728 'markdown-pre-face)
(markdown-test-range-has-face 2730 2732 'markdown-markup-face)))
(ert-deftest test-markdown-gfm/italic-1 ()
"GFM italic font lock test."
(markdown-test-file-gfm "gfm.text"
(markdown-test-range-has-face 1483 1483 'markdown-markup-face)
(markdown-test-range-has-face 1484 1487 'markdown-italic-face)
(markdown-test-range-has-face 1488 1488 'markdown-markup-face)
(markdown-test-range-has-face 1729 1790 nil)))
(ert-deftest test-markdown-gfm/strike-through-1 ()
"GFM strike through font lock test."
(markdown-test-string-gfm "one ~~two~~ three"
(markdown-test-range-has-face 1 4 nil)
(markdown-test-range-has-face 5 6 'markdown-markup-face)
(markdown-test-range-has-face 7 9 'markdown-strike-through-face)
(markdown-test-range-has-face 10 11 'markdown-markup-face)
(markdown-test-range-has-face 12 17 nil)))
(ert-deftest test-markdown-gfm/toggle-strike-through ()
"Test toggling functionality of `markdown-insert-strike-through'."
(markdown-test-string-gfm "one ~~two~~ three"
(forward-word 2)
(markdown-insert-strike-through)
(should (string-equal (buffer-string) "one two three"))
(should (= (point) 8))
(forward-word)
(markdown-insert-strike-through)
(should (= (point) 16))
(should (string-equal (buffer-string) "one two ~~three~~"))))
(ert-deftest test-markdown-gfm/insert-code-block-empty-markup ()
"Test GFM code block insertion with empty code section."
(markdown-test-string-gfm "line 1\nline 2\n"
(end-of-line)
(markdown-insert-gfm-code-block "elisp")
(should (equal (car markdown-gfm-used-languages) "elisp"))
(should (equal (car (markdown-gfm-get-corpus)) "elisp"))
(should (string-equal (buffer-string)
"line 1\n\n``` elisp\n\n```\n\nline 2\n"))))
(ert-deftest test-markdown-gfm/markdown-spaces-after-code-fence ()
"Test `markdown-spaces-after-code-fence'."
(markdown-test-string-gfm ""
(let ((markdown-spaces-after-code-fence 0))
(markdown-insert-gfm-code-block "elisp")
(should (equal (buffer-string) "```elisp\n\n```")))))
(ert-deftest test-markdown-gfm/insert-code-block-active-region ()
"Test GFM code block insertion with active region."
(markdown-test-string-gfm "line 1\nline 2\nline 3\n"
(forward-line)
(transient-mark-mode)
(push-mark (point) t t)
(end-of-line)
(should (markdown-use-region-p))
(markdown-insert-gfm-code-block "elisp")
(should (string-equal (buffer-string)
"line 1\n\n``` elisp\nline 2\n```\n\nline 3\n"))))
(ert-deftest test-markdown-gfm/insert-code-block-indented-list-item ()
"Test GFM code block insertion with an indented list item."
(markdown-test-string-gfm "1. foo\n "
(goto-char (point-max))
(markdown-insert-gfm-code-block "elisp")
(should (equal (buffer-substring-no-properties (point-min) (point-max))
"1. foo\n\n ``` elisp\n \n ```"))
(should (equal (buffer-substring-no-properties (point) (point-max))
"\n ```"))))
(ert-deftest test-markdown-gfm/insert-code-block-indented-list-item-active-region ()
"Test GFM code block insertion with an indented list item and active region."
(markdown-test-string-gfm "1. foo\n bar\n"
(let ((transient-mark-mode t))
(forward-line)
(push-mark nil :nomsg :activate)
(end-of-line)
(should (markdown-use-region-p))
(markdown-insert-gfm-code-block "elisp"))
(should (equal (buffer-substring-no-properties (point-min) (point-max))
"1. foo\n\n ``` elisp\n bar\n ```\n\n"))
(should (equal (buffer-substring-no-properties (point) (point-max))
"\n bar\n ```\n\n"))))
(ert-deftest test-markdown-gfm/gfm-parse-buffer-for-languages ()
"Parse buffer for existing languages for `markdown-gfm-used-languages' test."
(markdown-test-string-gfm "``` MADEUP\n\n```\n``` LANGUAGES\n\n```\n```MaDeUp\n\n```\n```\n\n```\n``` \n\n```\n"
(markdown-gfm-parse-buffer-for-languages)
(should (equal markdown-gfm-used-languages
(list "MaDeUp" "LANGUAGES" "MADEUP")))
(should (equal (car markdown-gfm-used-languages) "MaDeUp"))
(should (equal (car (markdown-gfm-get-corpus)) "MaDeUp"))
(goto-char (point-max))
(markdown-insert-gfm-code-block "newlang")
(should (equal markdown-gfm-used-languages
(list "newlang" "MaDeUp" "LANGUAGES" "MADEUP")))
(should (equal (car markdown-gfm-used-languages) "newlang"))
(should (equal (car (markdown-gfm-get-corpus)) "newlang"))
(let ((markdown-gfm-downcase-languages nil))
(should
(equal (markdown-gfm-get-corpus)
(append markdown-gfm-used-languages
markdown-gfm-additional-languages
markdown-gfm-recognized-languages))))
(let ((markdown-gfm-downcase-languages t))
(should
(equal
(markdown-gfm-get-corpus)
(append markdown-gfm-used-languages
(cl-mapcar #'downcase
(append markdown-gfm-additional-languages
markdown-gfm-recognized-languages))))))))
(ert-deftest test-markdown-gfm/code-block-font-lock ()
"GFM code block font lock test."
(markdown-test-file-gfm "gfm.text"
(markdown-test-range-has-face 2639 2641 'markdown-markup-face) ; ```
(markdown-test-range-has-face 2642 2645 'markdown-language-keyword-face) ; lang
(markdown-test-range-has-face 2647 2728 'markdown-pre-face) ; code
(markdown-test-range-has-face 2730 2732 'markdown-markup-face))) ; ```
(ert-deftest test-markdown-gfm/code-block-font-lock-2 ()
"GFM code block font lock test without language identifier."
(markdown-test-string-gfm "Plain code block:\n\n```\nfoo\n```\n"
(markdown-test-range-has-face 20 22 'markdown-markup-face)
(markdown-test-range-has-face 24 26 'markdown-pre-face)
(markdown-test-range-has-face 28 30 'markdown-markup-face)))
;;; Extension: GFM simplified tables
(ert-deftest test-markdown-gfm/false-table-first-line ()
"Test beginning of table detection at beginning of buffer.
Based on GH-298."
(markdown-test-string
"[|"
(should-not (gfm--table-at-point-p))))
(ert-deftest test-markdown-gfm/true-table-first-line ()
"Test beginning of table detection at beginning of buffer."
(markdown-test-string
"[|
-|-
x|"
(dotimes (x 3)
(should (gfm--table-at-point-p))
(forward-line))))
(ert-deftest test-markdown-gfm/table-begin-top-of-file ()
"Test beginning of table detection at top of file."
(markdown-test-string "[|"
(should-not (gfm--table-at-point-p))))
;;; Tests for other extensions:
(ert-deftest test-markdown-ext/pandoc-fancy-lists ()
"Test basic support for font lock and filling of Pandoc 'fancy lists'."
(markdown-test-string " #. abc\ndef\n"
;; font lock
(markdown-test-range-has-face 1 1 nil)
(markdown-test-range-has-face 2 3 'markdown-list-face)
(markdown-test-range-has-face 4 11 nil)
;; filling
(forward-line)
(markdown-indent-region (line-beginning-position) (line-end-position) nil)
(should (string-equal (buffer-string) " #. abc\n def\n"))
(markdown-indent-region (line-beginning-position) (line-end-position) nil)
(should (string-equal (buffer-string) " #. abc\n def\n"))))
(ert-deftest test-markdown-ext/wiki-link-rules ()
"Test wiki link search rules and font lock for missing pages."
(let ((markdown-enable-wiki-links t)
(markdown-wiki-link-fontify-missing t)
(markdown-wiki-link-search-subdirectories t)
(markdown-wiki-link-search-parent-directories t))
(progn
(find-file "wiki/root")
(unwind-protect
(progn
(markdown-mode)
;; search rules
(should (string-match-p
"/sub/foo$"
(markdown-convert-wiki-link-to-filename "foo")))
(should (string-equal
(markdown-convert-wiki-link-to-filename "doesnotexist")
"doesnotexist"))
;; font lock
(markdown-test-range-has-property 1 11 'font-lock-face 'markdown-link-face)
(markdown-test-range-has-property 14 33 'font-lock-face 'markdown-missing-link-face)
(markdown-test-range-has-property 36 42 'font-lock-face 'markdown-link-face)
(markdown-test-range-has-property 45 60 'font-lock-face 'markdown-missing-link-face))
(kill-buffer)))
(progn
(find-file "wiki/sub/foo")
(unwind-protect
(progn
(markdown-mode)
;; search rules
(should (string-match-p
"/wiki/root$"
(markdown-convert-wiki-link-to-filename "root")))
(should (string-equal
(markdown-convert-wiki-link-to-filename "doesnotexist")
"doesnotexist"))
;; font lock
(markdown-test-range-has-property 1 16 'font-lock-face 'markdown-missing-link-face)
(markdown-test-range-has-property 19 26 'font-lock-face 'markdown-link-face))
(kill-buffer)))))
(defadvice markdown-live-preview-window-eww
(around markdown-test-create-fake-eww disable)
(setq ad-return-value (get-buffer-create "*eww*")))
(defmacro markdown-test-fake-eww (&rest body)
`(progn
,@(if (and (fboundp 'libxml-parse-html-region) (require 'eww nil t)) body
`((ad-enable-advice #'markdown-live-preview-window-eww
'around 'markdown-test-create-fake-eww)
(ad-activate #'markdown-live-preview-window-eww)
,@body
(ad-disable-advice #'markdown-live-preview-window-eww
'around 'markdown-test-create-fake-eww)
(ad-activate #'markdown-live-preview-window-eww)))))
(defmacro markdown-test-eww-or-nothing (test &rest body)
(if (and (fboundp 'libxml-parse-html-region) (require 'eww nil t)
(executable-find markdown-command))
`(progn ,@body)
(message "no eww, no libxml2, or no %s found: skipping %s" markdown-command test)
nil))
(ert-deftest test-markdown-ext/live-preview-no-file ()
"Live-preview a `markdown-mode' buffer without a file."
(with-temp-buffer
(markdown-mode)
;; Activating `markdown-live-preview-mode' signals error
(should-error (markdown-live-preview-mode))
;; After trying to activate live preview mode, mode is not activated
(should-not markdown-live-preview-mode)
;; `markdown-live-preview-export' does nothing
(should-not (markdown-live-preview-export))
;; `markdown-live-preview-remove' does nothing
(should-not (markdown-live-preview-remove))))
(ert-deftest test-markdown-ext/live-preview-exports ()
(markdown-test-temp-file "inline.text"
(unless (and (fboundp 'libxml-parse-html-region) (require 'eww nil t))
(should-error (markdown-live-preview-mode)))
(markdown-test-fake-eww
(markdown-live-preview-mode)
(should (buffer-live-p markdown-live-preview-buffer))
(should (eq (current-buffer)
(with-current-buffer markdown-live-preview-buffer
markdown-live-preview-source-buffer)))
(kill-buffer markdown-live-preview-buffer)
(should (null markdown-live-preview-buffer))
(set-buffer-modified-p t)
(save-buffer) ; should create new export
(should (buffer-live-p markdown-live-preview-buffer)))))
(ert-deftest test-markdown-ext/live-preview-delete-exports ()
(markdown-test-fake-eww
(let ((markdown-live-preview-delete-export 'delete-on-destroy)
file-output)
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(setq file-output (markdown-export-file-name)))
(should-not (file-exists-p file-output)))
(let ((markdown-live-preview-delete-export 'delete-on-export)
file-output)
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(setq file-output (markdown-export-file-name))
(should-not (file-exists-p file-output))))
(let ((markdown-live-preview-delete-export nil)
file-output)
(unwind-protect
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(setq file-output (markdown-export-file-name))
(should (file-exists-p file-output)))
(delete-file file-output)))))
(ert-deftest test-markdown-ext/live-preview-follow-min-max ()
(markdown-test-eww-or-nothing "live-preview-follow-min-max"
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(should (buffer-live-p markdown-live-preview-buffer))
(should (window-live-p (get-buffer-window markdown-live-preview-buffer)))
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(goto-char (point-min)))
(goto-char (point-min))
(insert "a test ")
(markdown-live-preview-export)
(let (final-pt final-win-st-diff)
;; test that still starts at point-min
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(should (= (window-point) 1))
(should (= (markdown-visual-lines-between-points
(window-start) (window-point))
0))
(set-window-point (selected-window) (point-max))
(setq final-pt (window-point)
final-win-st-diff (markdown-visual-lines-between-points
(window-start) (window-point))))
(goto-char (point-min))
(insert "this is ")
(markdown-live-preview-export)
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(should (= (window-point) (+ final-pt (length "this is "))))
(should (= (markdown-visual-lines-between-points
(window-start) (window-point))
final-win-st-diff))
;; test that still starts at point-max, with correct line difference
(goto-char (floor (/ (float (- (point-max) (point-min))) 2)))
(setq final-pt (window-point)
final-win-st-diff (markdown-visual-lines-between-points
(window-start) final-pt)))
(markdown-live-preview-export)
;; test that still starts at same point, with correct line difference
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(should (= (window-point) final-pt))
(should (= (markdown-visual-lines-between-points
(window-start) (window-point))
final-win-st-diff)))))))
;; Tests for imenu
(ert-deftest test-markdown-imenu/metadata ()
"Don't correct header like statement in metadata.
https://github.com/jrblevin/markdown-mode/issues/145"
(markdown-test-string "---
title = \"Blah\"
comments = false
---
# Header1
## Header2
"
(let ((headers (mapcar #'car (markdown-imenu-create-flat-index))))
(should (member "Header1" headers))
(should (member "Header2" headers))
(should-not (member "comments = false" headers)))))
(ert-deftest test-markdown-imenu/include-footnotes ()
"Check that footnotes are added to the imenu.
https://github.com/jrblevin/markdown-mode/issues/235"
(markdown-test-string "# H1
[^fn1]: footnote 1
## H2
[^fn2]: footnote 2
"
(let* ((markdown-add-footnotes-to-imenu t)
(entries (mapcar #'car (markdown-imenu-create-flat-index))))
(should (member "^fn1" entries))
(should (member "^fn2" entries)))))
(ert-deftest test-markdown-imenu/no-footnotes ()
"Check that footnotes are not added to the imenu.
https://github.com/jrblevin/markdown-mode/issues/235"
(markdown-test-string "# H1
[^fn1]: footnote 1
## H2
[^fn2]: footnote 2
"
(let* ((markdown-add-footnotes-to-imenu nil)
(entries (mapcar #'car (markdown-imenu-create-flat-index))))
(should-not (member "^fn1" entries))
(should-not (member "^fn2" entries)))))
(ert-deftest test-markdown-command/function ()
"Test ‘markdown’ with ‘markdown-command’ being a function."
(markdown-test-string "foo"
(let* ((calls ())
(markdown-command (lambda (&rest args) (push args calls)))
(buffer-name (markdown))
(buffer (get-buffer buffer-name)))
(should (stringp buffer-name))
(should (buffer-live-p buffer))
(should (equal calls `((1 4 ,buffer)))))))
(ert-deftest test-markdown-open-command/function ()
"Test ‘markdown-open’ with ‘markdown-open-command’ being a function."
(markdown-test-string ""
(let* ((calls 0)
(markdown-open-command (lambda () (cl-incf calls))))
(markdown-open)
(should (equal calls 1)))))
(provide 'markdown-test)
;;; markdown-test.el ends here
markdown-mode-2.3+154/tests/math.text 0000664 0000000 0000000 00000001160 13217531627 0017435 0 ustar 00root root 0000000 0000000 A simple equation for a line in $\mathbb{R}^2$:
\[ y = mx + b \]
Again, but with dollar signs:
$$ y = mx + b $$
# Regarding $\vec g$ and its effects
Math in a heading
~~~~ {.haskell}
f x = length $ tail x
~~~~
$x + 1$
$e_{ik}$ in the statement the theorem about $V_k$
$**η = (-1)^{k(n-k)}sη$, where $**η$, is the Hodge star applied twice.
\[ a_1 \]
This is neither math nor italic
\[ a_2 \]
Support brackets with two backslashes, as do MultiMarkdown and Pandoc:
\\[
\Gamma(x) = \int_0^\infty t^{x-1}{\mathrm{e}}^{-t}\,{\mathrm{d}}
\\]
markdown-mode-2.3+154/tests/more-lists.text 0000664 0000000 0000000 00000001245 13217531627 0020606 0 ustar 00root root 0000000 0000000 Ordered, without paragraphs:
1. Foo
2. Bar
Unordered, with paragraphs:
* A list item.
With multiple paragraphs.
* Bar
Nested lists:
* Bubbles
1. bunk
2. bupkis
* BELITTLER
3. burper
* Abacus
* answer
* Cunning
A complex, multiply-nested list:
* Unordered stuff
with overhang
4. fourth nested
2. second nested
0. zeroth nested
* More unordered stuff
0. zeroth nested
2. second nested
4. fourth nested
Nested ordered lists:
1. first
0. zeroth nested
2. second nested
4. fourth nested
2. second
1. first nested
3. third nested
3. third
4. fourth
markdown-mode-2.3+154/tests/nested-list.text 0000664 0000000 0000000 00000001105 13217531627 0020736 0 ustar 00root root 0000000 0000000 - List level 1 item 1
- List level 1 item 2
Second paragraph of item 2
Nested pre block in item 2
Four spaces past the marker
Another paragraph of item 2
- List level 1 item 3
- List level 2 item 1
Four spaces from higher-level the marker.
More indentation in the same block
does not trigger a pre block!
Nested pre block
Four spaces past the previous marker
- List level 2 item 2
- List level 3 item 1
Nested pre block
markdown-mode-2.3+154/tests/outline-code.text 0000664 0000000 0000000 00000000300 13217531627 0021066 0 ustar 00root root 0000000 0000000 # Level one
* A list item
with some overhang
+ and a sublist
## Level two
~~~ {.bash}
#!/bin/bash
# In a code block, this shouldn't be a header
~~~
# Level one again
some body text
markdown-mode-2.3+154/tests/outline.text 0000664 0000000 0000000 00000001050 13217531627 0020161 0 ustar 00root root 0000000 0000000 Pre-header text.
# A top-level header
followed by some body text
## A second-level header
followed by some body text
### Third level ###
* A list item
* and another
with some overhang
+ and a sublist
with overhang
- And a third with a different marker
### Third level number two ###
### Level two again
followed by some body text
An underline-style header
=========================
With some text
And a level two underline header
--------------------------------
* With
* an unordered
* list
# Level one
foo
## Level two
bar
markdown-mode-2.3+154/tests/r-markdown-test.text 0000664 0000000 0000000 00000000474 13217531627 0021551 0 ustar 00root root 0000000 0000000 % Test example
% Mathieu Basille
% September 11, 2013
# First section
## And a sub-section
```{r sum}
2+2
```
Some text...
## Second sub-section
Some more text, and the faulty chunk with comments:
```{r comments}
2+2
## Wait, still 4?
```
And text you will never see again!
# Second section
More text...
markdown-mode-2.3+154/tests/syntax.text 0000664 0000000 0000000 00000066210 13217531627 0020041 0 ustar 00root root 0000000 0000000 Markdown: Syntax
================
* [Overview](#overview)
* [Philosophy](#philosophy)
* [Inline HTML](#html)
* [Automatic Escaping for Special Characters](#autoescape)
* [Block Elements](#block)
* [Paragraphs and Line Breaks](#p)
* [Headers](#header)
* [Blockquotes](#blockquote)
* [Lists](#list)
* [Code Blocks](#precode)
* [Horizontal Rules](#hr)
* [Span Elements](#span)
* [Links](#link)
* [Emphasis](#em)
* [Code](#code)
* [Images](#img)
* [Miscellaneous](#misc)
* [Backslash Escapes](#backslash)
* [Automatic Links](#autolink)
**Note:** This document is itself written using Markdown; you
can [see the source for it by adding '.text' to the URL][src].
[src]: /projects/markdown/syntax.text
* * *
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] [1], [atx] [2], [Textile] [3], [reStructuredText] [4],
[Grutatext] [5], and [EtText] [6] -- the single biggest source of
inspiration for Markdown's syntax is the format of plain text email.
[1]: http://docutils.sourceforge.net/mirror/setext.html
[2]: http://www.aaronsw.com/2002/atx/
[3]: http://textism.com/tools/textile/
[4]: http://docutils.sourceforge.net/rst.html
[5]: http://www.triptico.com/software/grutatxt.html
[6]: http://ettext.taint.org/doc/
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. ``,
`
- \n```"
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face)))))
(ert-deftest test-markdown-font-lock/html-tag-in-code-block ()
"Test that HTML tags are not matched inside code blocks."
(markdown-test-string "
- "
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face)))))
(ert-deftest test-markdown-font-lock/html-tag-in-inline-code ()
"Test that HTML tags are not matched inside inline code spans."
(markdown-test-string "`
- `"
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face)))))
(ert-deftest test-markdown-font-lock/html-disabled ()
"Test disabling font-lock for HTML tags"
(let ((markdown-enable-html nil))
(markdown-test-file "syntax.text"
(should-not
(markdown-range-property-any
(point-min) (point-max) 'face
'(markdown-html-tag-name-face
markdown-html-tag-delimiter-face
markdown-html-attr-name-face
markdown-html-attr-value-face))))))
;;; Markdown Parsing Functions:
(ert-deftest test-markdown-parsing/extend-region-function ()
"Test `markdown-syntax-propertize-extend-region'.
Should return a cons (NEW-START . NEW-END) or nil if no
adjustment should be made. Function is called repeatedly until it
returns nil."
(markdown-test-file
"inline.text"
(should (equal (markdown-syntax-propertize-extend-region 1 17)
(cons 1 91)))
(should (equal (markdown-syntax-propertize-extend-region 2 17)
(cons 1 91)))
(should (equal (markdown-syntax-propertize-extend-region 1 91)
nil))
(should (equal (markdown-syntax-propertize-extend-region 93 157)
nil))
(should (equal (markdown-syntax-propertize-extend-region 496 502)
(cons 486 510)))
(should (equal (markdown-syntax-propertize-extend-region 486 510)
nil))
;; Region that begins and ends with \n\n should not be extended
(should (equal (markdown-syntax-propertize-extend-region 157 355)
nil))))
(defun markdown-test-check-match-limits (prop num begin end &optional pos)
(let* ((posn (or pos (point)))
(props (get-text-property posn prop)))
(save-match-data
(set-match-data props)
(should (match-beginning num))
(should (match-end num))
(should (= (match-beginning num) begin))
(should (= (match-end num) end)))))
(ert-deftest test-markdown-parsing/syntax-with-adjacent-code-blocks ()
"Test `markdown-syntax-propertize-fenced-code-blocks' with adjacent blocks."
(markdown-test-string
"~~~ shell
#!/bin/sh
echo \"Hello, world!\"
~~~
~~~ shell
#!/bin/sh
echo \"Hello, world v2!\"
~~~
"
(let ((start-top-1 (make-marker)) (end-top-1 (make-marker))
(start-lang-1 (make-marker)) (end-lang-1 (make-marker))
(start-mid-1 (make-marker)) (end-mid-1 (make-marker))
(start-bottom-1 (make-marker)) (end-bottom-1 (make-marker))
(between (make-marker))
(start-top-2 (make-marker)) (end-top-2 (make-marker))
(start-lang-2 (make-marker)) (end-lang-2 (make-marker))
(start-mid-2 (make-marker)) (end-mid-2 (make-marker))
(start-bottom-2 (make-marker)) (end-bottom-2 (make-marker)))
;; First code block
(set-marker start-top-1 1)
(set-marker end-top-1 4)
(set-marker start-lang-1 5)
(set-marker end-lang-1 10)
(set-marker start-mid-1 11)
(set-marker end-mid-1 43)
(set-marker start-bottom-1 43)
(set-marker end-bottom-1 46)
;; check top tildes
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-1)
(marker-position end-top-1) (marker-position start-top-1))
;; check top language specifier
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-1)
(marker-position end-lang-1) (marker-position start-lang-1))
;; check text in between
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-1)
(marker-position end-mid-1) (marker-position start-mid-1))
;; check bottom tildes
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-1)
(marker-position end-bottom-1) (marker-position start-bottom-1))
;; Point between code blocks
(set-marker between 47)
(should (equal (get-text-property between 'markdown-fenced-code)
nil))
;; Second code block
(set-marker start-top-2 48)
(set-marker end-top-2 51)
(set-marker start-lang-2 52)
(set-marker end-lang-2 57)
(set-marker start-mid-2 58)
(set-marker end-mid-2 93)
(set-marker start-bottom-2 93)
(set-marker end-bottom-2 96)
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-2)
(marker-position end-top-2) (marker-position start-top-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-2)
(marker-position end-lang-2) (marker-position start-lang-2))
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-2)
(marker-position end-mid-2) (marker-position start-mid-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-2)
(marker-position end-bottom-2) (marker-position start-bottom-2))
;; ;; Move point between code blocks and insert a character
(goto-char between)
(insert "x")
;; Re-propertize region after change
(let ((range (markdown-syntax-propertize-extend-region (1- between) (point-max))))
(markdown-syntax-propertize (car range) (cdr range)))
;; Re-check first code block
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-1)
(marker-position end-top-1) (marker-position start-top-1))
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-1)
(marker-position end-lang-1) (marker-position start-lang-1))
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-1)
(marker-position end-mid-1) (marker-position start-mid-1))
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-1)
(marker-position end-bottom-1) (marker-position start-bottom-1))
;; Re-check point between code blocks
(should (equal (get-text-property between 'markdown-fenced-code)
nil))
;; Re-check second code block
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 1 (marker-position start-top-2)
(marker-position end-top-2) (marker-position start-top-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-begin 3 (marker-position start-lang-2)
(marker-position end-lang-2) (marker-position start-lang-2))
(markdown-test-check-match-limits
'markdown-fenced-code 0 (marker-position start-mid-2)
(marker-position end-mid-2) (marker-position start-mid-2))
(markdown-test-check-match-limits
'markdown-tilde-fence-end 1 (marker-position start-bottom-2)
(marker-position end-bottom-2)
(marker-position start-bottom-2)))))
(ert-deftest test-markdown-parsing/propertize-fenced-in-between ()
"Test whether `markdown-syntax-propertize-fenced-block-constructs' handles the
case when it can't propertize both the start and end of a fenced block within a
single pass (the end of the block is past the END argument)."
(markdown-test-string
"~~~ shell
#!/bin/sh
echo \"Hello, world!\"
~~~
"
(set-text-properties (point-min) (point-max) nil)
;; syntax-propertize up to right after hashbang
(markdown-syntax-propertize-fenced-block-constructs (point-min) 21)
;; ~~~ shell should be propertized, but nothing else
;; check tildes
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 1 1 4 1)
;; check language
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 3 5 10 5)
;; middle should not be propertized
(should-not (get-text-property 11 'markdown-fenced-code))
;; neither should end
(should-not (get-text-property 43 'markdown-tilde-fence-end))
(markdown-syntax-propertize-fenced-block-constructs 21 (point-max))
;; everything should be propertized now
;; re-check top
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 1 1 4 1)
(markdown-test-check-match-limits 'markdown-tilde-fence-begin 3 5 10 5)
;; check middle
(markdown-test-check-match-limits 'markdown-fenced-code 0 10 43 10)
;; check ending tildes
(markdown-test-check-match-limits 'markdown-tilde-fence-end 1 43 46 43)))
(ert-deftest test-markdown-parsing/get-code-block-at-pos ()
"Test whether `markdown-code-block-at-pos' works in all situations. All
situations are:
1. pre block
2. tilde block
3. gfm block
4. yaml metadata block"
(let ((markdown-use-pandoc-style-yaml-metadata t))
(markdown-test-string
"
~~~ ruby
some_ruby_fun()
~~~
---
a: b
---
``` {.bash}
#!/bin/sh
echo hey
```
pre code
random stuff
more preformatted code
---
data: pandoc
...
"
;; start/mid/end at tilde block
(should (equal (markdown-code-block-at-pos 2) (list 2 30)))
(should (equal (markdown-code-block-at-pos 11) (list 2 30)))
(should (equal (markdown-code-block-at-pos 27) (list 2 30)))
;; yaml metadata block
(should (equal (markdown-code-block-at-pos 32) (list 32 44)))
(should (equal (markdown-code-block-at-pos 36) (list 32 44)))
(should (equal (markdown-code-block-at-pos 41) (list 32 44)))
;; gfm block
(should (equal (markdown-code-block-at-pos 46) (list 46 80)))
(should (equal (markdown-code-block-at-pos 58) (list 46 80)))
(should (equal (markdown-code-block-at-pos 77) (list 46 80)))
;; pre block
(should (equal (markdown-code-block-at-pos 82) (list 82 138)))
(should (equal (markdown-code-block-at-pos 99) (list 82 138)))
(should (equal (markdown-code-block-at-pos 137) (list 82 138)))
;; pandoc yaml metadata block (should work if yaml above works)
(should (equal (markdown-code-block-at-pos 140) (list 140 160)))
(should (equal (markdown-code-block-at-pos 142) (list 140 160)))
(should (equal (markdown-code-block-at-pos 144) (list 140 160)))
(should (equal (markdown-code-block-at-pos 157) (list 140 160)))
(should (equal (markdown-code-block-at-pos 159) (list 140 160))))))
(ert-deftest test-markdown-parsing/syntax-get-fenced-blocks ()
"Test whether *-get-fenced-block-* functions work in the case where a block is
only partially propertized."
(save-match-data
(markdown-test-string
"~~~
"
(should (equal (markdown-syntax-propertize-extend-region
(point-min) (point-max))
nil))
(goto-char 1)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-begin))
(should (equal (markdown-get-fenced-block-from-start
'markdown-tilde-fence-begin)
nil)))
(markdown-test-string
"~~~
~~~"
(goto-char 1)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-begin))
(should (equal (markdown-get-fenced-block-from-start
'markdown-tilde-fence-begin)
(list 1 8)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 8)))
;; markdown-code-block-at-point-p should not modify match data
(set-match-data (list 1 2 3 4))
(should (markdown-code-block-at-point-p))
(should (equal (match-data) (list 1 2 3 4)))
(goto-char 5)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-end))
(should (equal (markdown-get-fenced-block-from-end
'markdown-tilde-fence-end)
(list 1 8)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 8))))
(markdown-test-string
"~~~
~~~"
(goto-char 1)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-begin))
(should (equal (markdown-get-fenced-block-from-start
'markdown-tilde-fence-begin)
(list 1 9)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 9)))
(goto-char 5)
(set-match-data (markdown-text-property-at-point 'markdown-fenced-code))
(should (equal (markdown-get-fenced-block-from-middle
'markdown-fenced-code)
(list 1 9)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 9)))
(goto-char 6)
(set-match-data (markdown-text-property-at-point
'markdown-tilde-fence-end))
(should (equal (markdown-get-fenced-block-from-end
'markdown-tilde-fence-end)
(list 1 9)))
(should (equal (markdown-code-block-at-pos (point)) (list 1 9))))))
(ert-deftest test-markdown-parsing/reference-definition-basic ()
"Test reference definition function."
(markdown-test-file "syntax.text"
;; Test accuracy of returned text and bounds
(should (equal (markdown-reference-definition "1")
(list "http://docutils.sourceforge.net/mirror/setext.html" 1942 1992)))
(should (equal (markdown-reference-definition "2")
(list "http://www.aaronsw.com/2002/atx/" 2000 2032)))
;; Test that match data remains intact
(should (string-equal (match-string 5) "http://www.aaronsw.com/2002/atx/"))
;; Test anchor-only relative URL
(should (equal (markdown-reference-definition "bq")
(list "#blockquote" 7536 7547)))
;; Example references that appear in pre blocks in the text
(should (not (markdown-reference-definition "")))
(should (not (markdown-reference-definition "id")))
(should (not (markdown-reference-definition "foo")))
(should (not (markdown-reference-definition "A")))
(should (not (markdown-reference-definition "Google")))
;; Test that we don't pick up other text in square brackets
(should (not (markdown-reference-definition "blockquoting")))
(should (not (markdown-reference-definition "square brackets")))
;; Test case insensitivity
(should (equal (markdown-reference-definition "SRC")
(list "/projects/markdown/syntax.text" 1245 1275)))))
(ert-deftest test-markdown-parsing/get-defined-references ()
"Test `markdown-get-defined-references'."
(markdown-test-file "syntax.text"
(should (equal (markdown-get-defined-references)
'("src" "1" "2" "3" "4" "5" "6" "bq" "l"))))
(markdown-test-file "outline.text"
(should (equal (markdown-get-defined-references) nil)))
(markdown-test-file "wiki-links.text"
(should (equal (markdown-get-defined-references) nil))))
(ert-deftest test-markdown-parsing/get-used-uris ()
"Test `markdown-get-used-uris'."
(markdown-test-file "syntax.text"
(let ((uris (markdown-get-used-uris)))
(should (equal (nth 0 uris) "#overview"))
(should (equal (nth 20 uris) "http://www.aaronsw.com/2002/atx/"))
(should-not (member "http://example.com/" uris))
(should-not (member "address@example.com" uris)))))
(defun markdown-test-test-region (beg end)
(goto-char (1- beg))
(should-not (markdown-inline-code-at-point-p))
(goto-char (1+ end))
(should-not (markdown-inline-code-at-point-p))
(dolist (loc (number-sequence beg end))
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-beginning 0) beg))
(should (equal (match-end 0) end))))
(ert-deftest test-markdown-parsing/inline-code-at-point ()
"Test `markdown-inline-code-at-point'."
(markdown-test-file "inline.text"
(markdown-test-test-region 45 51) ; Regular code span
(markdown-test-test-region 61 90) ; Code containing backticks
(markdown-test-test-region 228 240) ; Backquotes at beginning
(markdown-test-test-region 341 352) ; Backquotes at end
(markdown-test-test-region 460 469) ; Backslash as final character
(markdown-test-test-region 657 667) ; A code span crossing lines
(markdown-test-test-region 749 758) ; Three backquotes on same line
(markdown-test-test-region 806 815) ; Three backquotes across lines
))
(ert-deftest test-markdown-parsing/inline-code-at-point-one-space ()
"Test `markdown-inline-code-at-point' with multiple code spans in a row."
(markdown-test-string "`foo` `bar` `baz`"
(dolist (loc (number-sequence 1 6))
(goto-char loc)
;; markdown-inline-code-at-point should set match data
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 1 6 1 2 2 5 5 6)))
;; markdown-inline-code-at-point-p should not modify match data
(set-match-data (list 1 2 3 4))
(should (markdown-inline-code-at-point-p))
(should (equal (match-data) (list 1 2 3 4))))
(dolist (loc (number-sequence 7 12))
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 7 12 7 8 8 11 11 12))))
(dolist (loc (number-sequence 13 18))
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 13 18 13 14 14 17 17 18))))))
(ert-deftest test-markdown-parsing/inline-code-at-point-no-space ()
"Test `markdown-inline-code-at-point' with multiple code spans in a row.."
(markdown-test-string "a`foo`b`bar`c`baz`d"
(goto-char 1) ; "a"
(should-not (markdown-inline-code-at-point-p))
(dolist (loc (number-sequence 2 7)) ; "`foo`b"
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 2 7 2 3 3 6 6 7))))
(dolist (loc (number-sequence 8 13)) ; "`bar`c"
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 8 13 8 9 9 12 12 13))))
(dolist (loc (number-sequence 14 19)) ; "`baz`d"
(goto-char loc)
(should (markdown-inline-code-at-point))
(should (equal (match-data) (list 14 19 14 15 15 18 18 19))))))
(ert-deftest test-markdown-parsing/code-at-point-blank-line ()
"Test `markdown-inline-code-at-point-p' at beginning of block."
(markdown-test-string "----------\n\n## foo\n"
(should-not (markdown-inline-code-at-point-p))
(forward-line)
(should-not (markdown-inline-code-at-point-p))
(forward-line)
(should-not (markdown-inline-code-at-point-p))))
(ert-deftest test-markdown-parsing/in-comment-p-position ()
"Test `markdown-in-comment-p'."
(markdown-test-string
"HTML comment"
(should (eq (point) (point-min)))
(should-not (markdown-in-comment-p (point-max)))
(should (eq (point) (point-min)))))
(ert-deftest test-markdown-parsing/match-comments ()
"Test `markdown-match-comments'."
(markdown-test-string
"HTML comment"
(should (markdown-match-comments (point-max)))
(should (eq (point) 18))
(should (equal (match-data) (list 6 18)))
(should-not (markdown-match-comments (point-max)))))
(ert-deftest test-markdown-parsing/range-property-any ()
"Test behavior of `markdown-range-property-any'."
(markdown-test-file
"inline.text"
(should (markdown-range-property-any
(point-min) (point-at-eol)
'face '(markdown-markup-face markdown-italic-face)))
(should-not (markdown-range-property-any
(point-min) (point-at-eol)
'face '(markdown-bold-face)))))
(ert-deftest test-markdown-parsing/inline-code ()
"Don't cause infinite loop for inline code just after metadata block
Detail: https://github.com/jrblevin/markdown-mode/issues/115"
(markdown-test-string "---
x: x
---
`x`
"
(should (markdown-match-code (point-max)))
(should (= (point) 18))
(should (equal (match-data t) '(14 17 14 15 15 16 16 17)))
(should-not (markdown-match-code (point-max)))))
(ert-deftest test-markdown-parsing/list-item-at-point ()
"Test `markdown-list-item-at-point-p'."
(markdown-test-file "lists.text"
(let ((orig-match-data '(1 2 3 4))
(not-list-points '(273 399 512 3615))
(list-points '(1063 1063 1176 1283 1659 1830 1919 2150
2393 2484 2762 2853 3097 3188 3700
3903 4009)))
;; markdown-inline-code-at-point-p should not modify match data
(set-match-data orig-match-data)
;; Not list items
(dolist (pos not-list-points)
(goto-char pos)
(should-not (markdown-list-item-at-point-p))
(should (equal (match-data) orig-match-data)))
;; List items
(dolist (pos list-points)
(goto-char pos)
(should (markdown-list-item-at-point-p))
(should (equal (match-data) orig-match-data))))))
(ert-deftest test-markdown-parsing/heading-at-point ()
"Test `markdown-heading-at-point'."
(save-match-data
(markdown-test-file "outline.text"
(should-not (markdown-heading-at-point))
(markdown-test-goto-heading "An underline-style header")
(forward-line -1)
(should (markdown-heading-at-point))
(should (equal (match-data t) (get-text-property (point) 'markdown-heading)))
(should (equal (match-data t) (get-text-property (point) 'markdown-heading-1-setext))))))
(ert-deftest test-markdown-parsing/inline-link-in-code-block ()
"Test `markdown-match-generic-links'."
(markdown-test-string " **bold**
_italic_
[link](url)
* list"
(goto-char (point-min))
;; The link inside the pre block should not match.
(should-not (markdown-match-generic-links (point-max) nil))
;; Point should be left at limit.
(should (= (point) (point-max)))))
(ert-deftest test-markdown-parsing/broken-inline-link ()
"Test `markdown-match-generic-links' with an invalid link."
(markdown-test-string "[site1](http://site1.com
[site2](http://site2.com)
[site3](http://site3.com)"
(goto-char (point-min))
(let ((limit (point-at-eol)))
;; The first link is broken and shouldn't match.
(should-not (markdown-match-generic-links limit nil))
;; Subsequent search shouldn't match, so point should move to limit.
(should (= (point) limit)))
;; The second link should still match, starting from (point-min).
(let ((limit (point-at-eol 2)))
(should (markdown-match-generic-links limit nil))
(should (= (point) (match-end 0))))
;; The third link should match when starting past the second one.
(goto-char (match-end 0))
(should (markdown-match-generic-links (point-max) nil))
(should (= (point) (match-end 0)))))
(ert-deftest test-markdown-parsing/code-block-lang ()
"Test `markdown-code-block-lang'."
;; Test with GFM code blocks.
(markdown-test-file "GFM.md"
;; Test a call with the optional argument.
(should (string-equal
(markdown-code-block-lang
'(1455 . markdown-gfm-block-begin)) "js"))
;; Test a call without the optional argument.
(goto-char 1504) ;; middle of a GFM code block
(should (string-equal (markdown-code-block-lang) "js")))
;; Test with tilde-fenced cdoe blocks.
(markdown-test-file "outline-code.text"
(goto-char 107) ;; middle of a tilde fenced code block
(should (string-equal (markdown-code-block-lang
'(83 . markdown-tilde-fence-begin)) "bash"))))
(ert-deftest test-markdown-parsing/code-block-lang-period ()
"Test `markdown-code-block-lang' when language name begins with a period."
(markdown-test-string "~~~ { .ruby }
puts 'hello, world'
~~~
"
(should (string-equal (markdown-code-block-lang) "ruby"))))
;;; Reference Checking:
(ert-deftest test-markdown-references/goto-line-button ()
"Create and test a goto line button."
(markdown-test-string "line 1\nline 2\n"
;; Store the temporary buffer with the text
(let ((target (current-buffer)))
;; Create a new buffer for inserting
(with-temp-buffer
;; Verify that point is in a different buffer
(should (not (equal (current-buffer) target)))
;; Insert and press the button
(insert-button "goto line 2"
:type 'markdown-goto-line-button
'target-buffer target
'target-line 2)
(should (string-equal (buffer-string) "goto line 2"))
(backward-button 1)
(call-interactively 'push-button)
;; Verify that point is on line 2 of target buffer
(should (= (line-number-at-pos) 2))
(should (looking-at "line 2"))
(should (equal (current-buffer) target))))))
(ert-deftest test-markdown-references/button-map ()
"Verify that button-buffer-map is used for check references buffer."
(markdown-test-string "[undefined][ref]\n"
(let* ((target (buffer-name))
(check (format "*Undefined references for %s*" target)))
(markdown-check-refs)
(with-current-buffer (get-buffer check)
(should (equal (local-key-binding (kbd "TAB")) 'forward-button))
(should (equal (local-key-binding (kbd "
title
")) (should-not (string-match markdown-xhtml-standalone-regexp "")))
(ert-deftest test-markdown-export/kill-buffer-nil ()
"Test `markdown-export-kill-buffer' equal to nil."
(markdown-test-temp-file "inline.text"
(let* ((markdown-export-kill-buffer nil)
(export-file (markdown-export))
(export-buffer (get-file-buffer export-file)))
;; Output buffer should remain open.
(should (member export-buffer (buffer-list))))))
(ert-deftest test-markdown-export/kill-buffer-t ()
"Test `markdown-export-kill-buffer' equal to t."
(markdown-test-temp-file "inline.text"
(let* ((markdown-export-kill-buffer t)
(export-file (markdown-export))
(export-buffer (get-file-buffer export-file)))
;; Output buffer should be killed.
(should-not export-buffer))))
;;; Hook tests:
(ert-deftest test-markdown-hook/before-export ()
"Test hook run before export XHTML."
(markdown-test-temp-file "lists.text"
(let* ((before-hook-run nil)
(orig-point (point))
(func (lambda ()
;; Change value of a variable
(setq before-hook-run t)
;; Insert some text
(goto-char (point-min))
(insert "#")
;; Deliberately move the point
(end-of-line)
;; Verify changes
(should (looking-back "^## List Cases" nil))
(should-not (= (point) orig-point))))
(ofile (progn
;; Register hook
(add-hook 'markdown-before-export-hook func)
;; Export XHTML and return filename
(markdown-export)))
(obuffer (get-file-buffer ofile)))
;; Test side effects of hook
(should (eq before-hook-run t))
;; Test position of point
(should (= (point) orig-point))
;; Test that buffer was restored to original state
(goto-char (point-min))
(should (looking-at "^# List Cases"))
;; Clean
(remove-hook 'markdown-before-export-hook func)
(kill-buffer obuffer)
(delete-file ofile))))
(ert-deftest test-markdown-hook/after-export ()
"Test hook run after export XHTML."
(markdown-test-temp-file "lists.text"
(let* ((after-hook-run nil)
(markdown-export-kill-buffer nil)
(func (lambda ()
;; Change variable value
(setq after-hook-run t)
;; Add comment to output buffer
(goto-char (point-min))
(insert "\n")))
(ofile (progn
;; Register hook
(add-hook 'markdown-after-export-hook func)
;; Export XHTML and return filename
(markdown-export)))
(obuffer (get-file-buffer ofile)))
(message "obuffer = %S" obuffer)
;; Test that variable was changed
(should (eq after-hook-run t))
;; Test that output buffer remains open
(should (get-buffer obuffer))
;; Test that output buffer modification remains
(with-current-buffer obuffer
(goto-char (point-min))
(should (looking-at "\n")))
;; Test that buffer modification was saved
(should-not (buffer-modified-p obuffer))
;; Clean up
(remove-hook 'markdown-after-export-hook func)
(kill-buffer obuffer)
(delete-file ofile))))
;;; Extension: math support
(ert-deftest test-markdown-math/file-local-variable ()
"Test enabling math mode via `hack-local-variables-hook'."
(markdown-test-file "math.text"
(should-not markdown-enable-math)
(hack-local-variables)
(should markdown-enable-math)))
(ert-deftest test-markdown-math/reload ()
"Test enabling math mode via variable `markdown-enable-math'."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
;; Flag should be set to t
(should markdown-enable-math)
;; Font-lock keywords should be updated.
(should (member (car markdown-mode-font-lock-keywords-math)
(cadr font-lock-keywords))))))
(ert-deftest test-markdown-math/preserve-user-keywords ()
"Test preserving user-specified font-lock keywords."
(let ((user-keyword '("\\<\\(FIXME\\):" 1 font-lock-warning-face t)))
;; Add user font-lock keyword using `font-lock-add-keywords'.
(font-lock-add-keywords 'markdown-mode (list user-keyword))
;; Visit a file using `markdown-mode'.
(markdown-test-file "math.text"
;; User keyword should be present initially.
(should (member user-keyword (cadr font-lock-keywords)))
;; User keyword should persist after calling `markdown-reload-extensions'.
(markdown-reload-extensions)
(should (member user-keyword (cadr font-lock-keywords))))
;; Remove the user keyword using `font-lock-remove-keywords'.
(font-lock-remove-keywords 'markdown-mode (list user-keyword))
;; Visit a file using `markdown-mode'.
(markdown-test-file "inline.text"
;; User keyword should not be present after removal.
(should-not (member user-keyword (cadr font-lock-keywords))))))
(ert-deftest test-markdown-math/preserve-local-user-keywords ()
"Test preserving buffer-specific user-specified font-lock keywords."
(let ((user-keyword '("\\<\\(FIXME\\):" 1 font-lock-warning-face t)))
;; Visit a file using `markdown-mode'.
(markdown-test-file "math.text"
;; Add user font-lock keyword using `font-lock-add-keywords'.
(font-lock-add-keywords nil (list user-keyword))
;; User keyword should be present initially.
(should (member user-keyword (cadr font-lock-keywords)))
;; User keyword should persist after calling `markdown-reload-extensions'.
(markdown-reload-extensions)
(should (member user-keyword (cadr font-lock-keywords)))
;; Remove the user keyword using `font-lock-remove-keywords'.
(font-lock-remove-keywords nil (list user-keyword))
;; User keyword should not be present after removal.
(should-not (member user-keyword (cadr font-lock-keywords))))))
(ert-deftest test-markdown-math/font-lock ()
"Test markdown math mode."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 1 32 nil)
(markdown-test-range-has-face 33 33 'markdown-markup-face)
(markdown-test-range-has-face 34 45 'markdown-math-face)
(markdown-test-range-has-face 46 46 'markdown-markup-face)
(markdown-test-range-has-face 47 49 nil)
(markdown-test-range-has-face 50 51 'markdown-markup-face)
(markdown-test-range-has-face 52 63 'markdown-math-face)
(markdown-test-range-has-face 64 65 'markdown-markup-face)
(markdown-test-range-has-face 66 98 nil)
(markdown-test-range-has-face 99 100 'markdown-markup-face)
(markdown-test-range-has-face 101 112 'markdown-math-face)
(markdown-test-range-has-face 113 114 'markdown-markup-face)
(markdown-test-range-has-face 113 114 'markdown-markup-face)
(markdown-test-range-has-face 117 117 'markdown-header-delimiter-face)
(markdown-test-range-has-face 119 152 'markdown-header-face-1)
(markdown-test-range-has-face 129 129 'markdown-markup-face)
(markdown-test-range-has-face 136 136 'markdown-markup-face)
(markdown-test-range-has-face 174 177 'markdown-markup-face)
(markdown-test-range-has-face 179 179 'markdown-markup-face)
(markdown-test-range-has-face 180 187 'markdown-language-keyword-face)
(markdown-test-range-has-face 188 188 'markdown-markup-face)
(markdown-test-range-has-face 190 210 'markdown-pre-face)
(markdown-test-range-has-face 212 215 'markdown-markup-face)
(markdown-test-range-has-face 218 218 'markdown-markup-face)
(markdown-test-range-has-face 219 223 'markdown-math-face)
(markdown-test-range-has-face 224 224 'markdown-markup-face)
(markdown-test-range-has-face 350 351 'markdown-markup-face)
(markdown-test-range-has-face 352 356 'markdown-math-face)
(markdown-test-range-has-face 357 358 'markdown-markup-face)
(markdown-test-range-has-face 359 391 nil)
(markdown-test-range-has-face 392 393 'markdown-markup-face)
(markdown-test-range-has-face 394 398 'markdown-math-face)
(markdown-test-range-has-face 399 400 'markdown-markup-face))))
(ert-deftest test-markdown-math/double-slash-display-math ()
"Test double slash display math font lock."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 403 474 nil)
(markdown-test-range-has-face 475 477 'markdown-markup-face)
(markdown-test-range-has-face 478 543 'markdown-math-face)
(markdown-test-range-has-face 544 546 'markdown-markup-face))))
(ert-deftest test-markdown-math/indented-double-slash-display-math ()
"Test font lock for indented double slash display math.
See GH-288."
(let ((markdown-enable-math t))
(markdown-test-string "- Einstein's equation:
\\\\[ E = m c^2 \\\\]"
(markdown-test-range-has-face 29 31 'markdown-markup-face)
(markdown-test-range-has-face 32 42 'markdown-math-face)
(markdown-test-range-has-face 43 45 'markdown-markup-face))))
(ert-deftest test-markdown-math/font-lock-italics ()
"Test markdown math mode with underscores."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 227 227 'markdown-markup-face)
(markdown-test-range-has-face 228 233 'markdown-math-face)
(markdown-test-range-has-face 234 234 'markdown-markup-face)
(markdown-test-range-has-face 235 270 nil)
(markdown-test-range-has-face 271 271 'markdown-markup-face)
(markdown-test-range-has-face 272 274 'markdown-math-face)
(markdown-test-range-has-face 275 275 'markdown-markup-face))))
(ert-deftest test-markdown-math/font-lock-no-bold ()
"Bold markers in math should not trigger bold."
(let ((markdown-enable-math t))
(markdown-test-file "math.text"
(markdown-test-range-has-face 279 299 'markdown-math-face)
(markdown-test-range-has-face 301 308 nil)
(markdown-test-range-has-face 310 312 'markdown-math-face))))
;;; Extension: pipe table editing
(ert-deftest test-markdown-table/table-begin-top-of-file ()
"Test beginning of table detection at top of file."
(markdown-test-string "\n| 1 | 2 |\n"
(should-not (markdown-table-at-point-p))
(forward-line)
(should (markdown-table-at-point-p))
(should (= (markdown-table-begin) 2))))
;;; gfm-mode tests:
(ert-deftest test-markdown-gfm/pre-1 ()
"GFM pre block font lock test."
(markdown-test-file-gfm "gfm.text"
(markdown-test-range-has-face 2626 2637 nil)
(markdown-test-range-has-face 2639 2641 'markdown-markup-face)
(markdown-test-range-has-face 2642 2645 'markdown-language-keyword-face)
(markdown-test-range-has-face 2647 2728 'markdown-pre-face)
(markdown-test-range-has-face 2730 2732 'markdown-markup-face)))
(ert-deftest test-markdown-gfm/italic-1 ()
"GFM italic font lock test."
(markdown-test-file-gfm "gfm.text"
(markdown-test-range-has-face 1483 1483 'markdown-markup-face)
(markdown-test-range-has-face 1484 1487 'markdown-italic-face)
(markdown-test-range-has-face 1488 1488 'markdown-markup-face)
(markdown-test-range-has-face 1729 1790 nil)))
(ert-deftest test-markdown-gfm/strike-through-1 ()
"GFM strike through font lock test."
(markdown-test-string-gfm "one ~~two~~ three"
(markdown-test-range-has-face 1 4 nil)
(markdown-test-range-has-face 5 6 'markdown-markup-face)
(markdown-test-range-has-face 7 9 'markdown-strike-through-face)
(markdown-test-range-has-face 10 11 'markdown-markup-face)
(markdown-test-range-has-face 12 17 nil)))
(ert-deftest test-markdown-gfm/toggle-strike-through ()
"Test toggling functionality of `markdown-insert-strike-through'."
(markdown-test-string-gfm "one ~~two~~ three"
(forward-word 2)
(markdown-insert-strike-through)
(should (string-equal (buffer-string) "one two three"))
(should (= (point) 8))
(forward-word)
(markdown-insert-strike-through)
(should (= (point) 16))
(should (string-equal (buffer-string) "one two ~~three~~"))))
(ert-deftest test-markdown-gfm/insert-code-block-empty-markup ()
"Test GFM code block insertion with empty code section."
(markdown-test-string-gfm "line 1\nline 2\n"
(end-of-line)
(markdown-insert-gfm-code-block "elisp")
(should (equal (car markdown-gfm-used-languages) "elisp"))
(should (equal (car (markdown-gfm-get-corpus)) "elisp"))
(should (string-equal (buffer-string)
"line 1\n\n``` elisp\n\n```\n\nline 2\n"))))
(ert-deftest test-markdown-gfm/markdown-spaces-after-code-fence ()
"Test `markdown-spaces-after-code-fence'."
(markdown-test-string-gfm ""
(let ((markdown-spaces-after-code-fence 0))
(markdown-insert-gfm-code-block "elisp")
(should (equal (buffer-string) "```elisp\n\n```")))))
(ert-deftest test-markdown-gfm/insert-code-block-active-region ()
"Test GFM code block insertion with active region."
(markdown-test-string-gfm "line 1\nline 2\nline 3\n"
(forward-line)
(transient-mark-mode)
(push-mark (point) t t)
(end-of-line)
(should (markdown-use-region-p))
(markdown-insert-gfm-code-block "elisp")
(should (string-equal (buffer-string)
"line 1\n\n``` elisp\nline 2\n```\n\nline 3\n"))))
(ert-deftest test-markdown-gfm/insert-code-block-indented-list-item ()
"Test GFM code block insertion with an indented list item."
(markdown-test-string-gfm "1. foo\n "
(goto-char (point-max))
(markdown-insert-gfm-code-block "elisp")
(should (equal (buffer-substring-no-properties (point-min) (point-max))
"1. foo\n\n ``` elisp\n \n ```"))
(should (equal (buffer-substring-no-properties (point) (point-max))
"\n ```"))))
(ert-deftest test-markdown-gfm/insert-code-block-indented-list-item-active-region ()
"Test GFM code block insertion with an indented list item and active region."
(markdown-test-string-gfm "1. foo\n bar\n"
(let ((transient-mark-mode t))
(forward-line)
(push-mark nil :nomsg :activate)
(end-of-line)
(should (markdown-use-region-p))
(markdown-insert-gfm-code-block "elisp"))
(should (equal (buffer-substring-no-properties (point-min) (point-max))
"1. foo\n\n ``` elisp\n bar\n ```\n\n"))
(should (equal (buffer-substring-no-properties (point) (point-max))
"\n bar\n ```\n\n"))))
(ert-deftest test-markdown-gfm/gfm-parse-buffer-for-languages ()
"Parse buffer for existing languages for `markdown-gfm-used-languages' test."
(markdown-test-string-gfm "``` MADEUP\n\n```\n``` LANGUAGES\n\n```\n```MaDeUp\n\n```\n```\n\n```\n``` \n\n```\n"
(markdown-gfm-parse-buffer-for-languages)
(should (equal markdown-gfm-used-languages
(list "MaDeUp" "LANGUAGES" "MADEUP")))
(should (equal (car markdown-gfm-used-languages) "MaDeUp"))
(should (equal (car (markdown-gfm-get-corpus)) "MaDeUp"))
(goto-char (point-max))
(markdown-insert-gfm-code-block "newlang")
(should (equal markdown-gfm-used-languages
(list "newlang" "MaDeUp" "LANGUAGES" "MADEUP")))
(should (equal (car markdown-gfm-used-languages) "newlang"))
(should (equal (car (markdown-gfm-get-corpus)) "newlang"))
(let ((markdown-gfm-downcase-languages nil))
(should
(equal (markdown-gfm-get-corpus)
(append markdown-gfm-used-languages
markdown-gfm-additional-languages
markdown-gfm-recognized-languages))))
(let ((markdown-gfm-downcase-languages t))
(should
(equal
(markdown-gfm-get-corpus)
(append markdown-gfm-used-languages
(cl-mapcar #'downcase
(append markdown-gfm-additional-languages
markdown-gfm-recognized-languages))))))))
(ert-deftest test-markdown-gfm/code-block-font-lock ()
"GFM code block font lock test."
(markdown-test-file-gfm "gfm.text"
(markdown-test-range-has-face 2639 2641 'markdown-markup-face) ; ```
(markdown-test-range-has-face 2642 2645 'markdown-language-keyword-face) ; lang
(markdown-test-range-has-face 2647 2728 'markdown-pre-face) ; code
(markdown-test-range-has-face 2730 2732 'markdown-markup-face))) ; ```
(ert-deftest test-markdown-gfm/code-block-font-lock-2 ()
"GFM code block font lock test without language identifier."
(markdown-test-string-gfm "Plain code block:\n\n```\nfoo\n```\n"
(markdown-test-range-has-face 20 22 'markdown-markup-face)
(markdown-test-range-has-face 24 26 'markdown-pre-face)
(markdown-test-range-has-face 28 30 'markdown-markup-face)))
;;; Extension: GFM simplified tables
(ert-deftest test-markdown-gfm/false-table-first-line ()
"Test beginning of table detection at beginning of buffer.
Based on GH-298."
(markdown-test-string
"[|"
(should-not (gfm--table-at-point-p))))
(ert-deftest test-markdown-gfm/true-table-first-line ()
"Test beginning of table detection at beginning of buffer."
(markdown-test-string
"[|
-|-
x|"
(dotimes (x 3)
(should (gfm--table-at-point-p))
(forward-line))))
(ert-deftest test-markdown-gfm/table-begin-top-of-file ()
"Test beginning of table detection at top of file."
(markdown-test-string "[|"
(should-not (gfm--table-at-point-p))))
;;; Tests for other extensions:
(ert-deftest test-markdown-ext/pandoc-fancy-lists ()
"Test basic support for font lock and filling of Pandoc 'fancy lists'."
(markdown-test-string " #. abc\ndef\n"
;; font lock
(markdown-test-range-has-face 1 1 nil)
(markdown-test-range-has-face 2 3 'markdown-list-face)
(markdown-test-range-has-face 4 11 nil)
;; filling
(forward-line)
(markdown-indent-region (line-beginning-position) (line-end-position) nil)
(should (string-equal (buffer-string) " #. abc\n def\n"))
(markdown-indent-region (line-beginning-position) (line-end-position) nil)
(should (string-equal (buffer-string) " #. abc\n def\n"))))
(ert-deftest test-markdown-ext/wiki-link-rules ()
"Test wiki link search rules and font lock for missing pages."
(let ((markdown-enable-wiki-links t)
(markdown-wiki-link-fontify-missing t)
(markdown-wiki-link-search-subdirectories t)
(markdown-wiki-link-search-parent-directories t))
(progn
(find-file "wiki/root")
(unwind-protect
(progn
(markdown-mode)
;; search rules
(should (string-match-p
"/sub/foo$"
(markdown-convert-wiki-link-to-filename "foo")))
(should (string-equal
(markdown-convert-wiki-link-to-filename "doesnotexist")
"doesnotexist"))
;; font lock
(markdown-test-range-has-property 1 11 'font-lock-face 'markdown-link-face)
(markdown-test-range-has-property 14 33 'font-lock-face 'markdown-missing-link-face)
(markdown-test-range-has-property 36 42 'font-lock-face 'markdown-link-face)
(markdown-test-range-has-property 45 60 'font-lock-face 'markdown-missing-link-face))
(kill-buffer)))
(progn
(find-file "wiki/sub/foo")
(unwind-protect
(progn
(markdown-mode)
;; search rules
(should (string-match-p
"/wiki/root$"
(markdown-convert-wiki-link-to-filename "root")))
(should (string-equal
(markdown-convert-wiki-link-to-filename "doesnotexist")
"doesnotexist"))
;; font lock
(markdown-test-range-has-property 1 16 'font-lock-face 'markdown-missing-link-face)
(markdown-test-range-has-property 19 26 'font-lock-face 'markdown-link-face))
(kill-buffer)))))
(defadvice markdown-live-preview-window-eww
(around markdown-test-create-fake-eww disable)
(setq ad-return-value (get-buffer-create "*eww*")))
(defmacro markdown-test-fake-eww (&rest body)
`(progn
,@(if (and (fboundp 'libxml-parse-html-region) (require 'eww nil t)) body
`((ad-enable-advice #'markdown-live-preview-window-eww
'around 'markdown-test-create-fake-eww)
(ad-activate #'markdown-live-preview-window-eww)
,@body
(ad-disable-advice #'markdown-live-preview-window-eww
'around 'markdown-test-create-fake-eww)
(ad-activate #'markdown-live-preview-window-eww)))))
(defmacro markdown-test-eww-or-nothing (test &rest body)
(if (and (fboundp 'libxml-parse-html-region) (require 'eww nil t)
(executable-find markdown-command))
`(progn ,@body)
(message "no eww, no libxml2, or no %s found: skipping %s" markdown-command test)
nil))
(ert-deftest test-markdown-ext/live-preview-no-file ()
"Live-preview a `markdown-mode' buffer without a file."
(with-temp-buffer
(markdown-mode)
;; Activating `markdown-live-preview-mode' signals error
(should-error (markdown-live-preview-mode))
;; After trying to activate live preview mode, mode is not activated
(should-not markdown-live-preview-mode)
;; `markdown-live-preview-export' does nothing
(should-not (markdown-live-preview-export))
;; `markdown-live-preview-remove' does nothing
(should-not (markdown-live-preview-remove))))
(ert-deftest test-markdown-ext/live-preview-exports ()
(markdown-test-temp-file "inline.text"
(unless (and (fboundp 'libxml-parse-html-region) (require 'eww nil t))
(should-error (markdown-live-preview-mode)))
(markdown-test-fake-eww
(markdown-live-preview-mode)
(should (buffer-live-p markdown-live-preview-buffer))
(should (eq (current-buffer)
(with-current-buffer markdown-live-preview-buffer
markdown-live-preview-source-buffer)))
(kill-buffer markdown-live-preview-buffer)
(should (null markdown-live-preview-buffer))
(set-buffer-modified-p t)
(save-buffer) ; should create new export
(should (buffer-live-p markdown-live-preview-buffer)))))
(ert-deftest test-markdown-ext/live-preview-delete-exports ()
(markdown-test-fake-eww
(let ((markdown-live-preview-delete-export 'delete-on-destroy)
file-output)
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(setq file-output (markdown-export-file-name)))
(should-not (file-exists-p file-output)))
(let ((markdown-live-preview-delete-export 'delete-on-export)
file-output)
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(setq file-output (markdown-export-file-name))
(should-not (file-exists-p file-output))))
(let ((markdown-live-preview-delete-export nil)
file-output)
(unwind-protect
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(setq file-output (markdown-export-file-name))
(should (file-exists-p file-output)))
(delete-file file-output)))))
(ert-deftest test-markdown-ext/live-preview-follow-min-max ()
(markdown-test-eww-or-nothing "live-preview-follow-min-max"
(markdown-test-temp-file "inline.text"
(markdown-live-preview-mode)
(should (buffer-live-p markdown-live-preview-buffer))
(should (window-live-p (get-buffer-window markdown-live-preview-buffer)))
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(goto-char (point-min)))
(goto-char (point-min))
(insert "a test ")
(markdown-live-preview-export)
(let (final-pt final-win-st-diff)
;; test that still starts at point-min
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(should (= (window-point) 1))
(should (= (markdown-visual-lines-between-points
(window-start) (window-point))
0))
(set-window-point (selected-window) (point-max))
(setq final-pt (window-point)
final-win-st-diff (markdown-visual-lines-between-points
(window-start) (window-point))))
(goto-char (point-min))
(insert "this is ")
(markdown-live-preview-export)
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(should (= (window-point) (+ final-pt (length "this is "))))
(should (= (markdown-visual-lines-between-points
(window-start) (window-point))
final-win-st-diff))
;; test that still starts at point-max, with correct line difference
(goto-char (floor (/ (float (- (point-max) (point-min))) 2)))
(setq final-pt (window-point)
final-win-st-diff (markdown-visual-lines-between-points
(window-start) final-pt)))
(markdown-live-preview-export)
;; test that still starts at same point, with correct line difference
(with-selected-window (get-buffer-window markdown-live-preview-buffer)
(should (= (window-point) final-pt))
(should (= (markdown-visual-lines-between-points
(window-start) (window-point))
final-win-st-diff)))))))
;; Tests for imenu
(ert-deftest test-markdown-imenu/metadata ()
"Don't correct header like statement in metadata.
https://github.com/jrblevin/markdown-mode/issues/145"
(markdown-test-string "---
title = \"Blah\"
comments = false
---
# Header1
## Header2
"
(let ((headers (mapcar #'car (markdown-imenu-create-flat-index))))
(should (member "Header1" headers))
(should (member "Header2" headers))
(should-not (member "comments = false" headers)))))
(ert-deftest test-markdown-imenu/include-footnotes ()
"Check that footnotes are added to the imenu.
https://github.com/jrblevin/markdown-mode/issues/235"
(markdown-test-string "# H1
[^fn1]: footnote 1
## H2
[^fn2]: footnote 2
"
(let* ((markdown-add-footnotes-to-imenu t)
(entries (mapcar #'car (markdown-imenu-create-flat-index))))
(should (member "^fn1" entries))
(should (member "^fn2" entries)))))
(ert-deftest test-markdown-imenu/no-footnotes ()
"Check that footnotes are not added to the imenu.
https://github.com/jrblevin/markdown-mode/issues/235"
(markdown-test-string "# H1
[^fn1]: footnote 1
## H2
[^fn2]: footnote 2
"
(let* ((markdown-add-footnotes-to-imenu nil)
(entries (mapcar #'car (markdown-imenu-create-flat-index))))
(should-not (member "^fn1" entries))
(should-not (member "^fn2" entries)))))
(ert-deftest test-markdown-command/function ()
"Test ‘markdown’ with ‘markdown-command’ being a function."
(markdown-test-string "foo"
(let* ((calls ())
(markdown-command (lambda (&rest args) (push args calls)))
(buffer-name (markdown))
(buffer (get-buffer buffer-name)))
(should (stringp buffer-name))
(should (buffer-live-p buffer))
(should (equal calls `((1 4 ,buffer)))))))
(ert-deftest test-markdown-open-command/function ()
"Test ‘markdown-open’ with ‘markdown-open-command’ being a function."
(markdown-test-string ""
(let* ((calls 0)
(markdown-open-command (lambda () (cl-incf calls))))
(markdown-open)
(should (equal calls 1)))))
(provide 'markdown-test)
;;; markdown-test.el ends here
markdown-mode-2.3+154/tests/math.text 0000664 0000000 0000000 00000001160 13217531627 0017435 0 ustar 00root root 0000000 0000000 A simple equation for a line in $\mathbb{R}^2$:
\[ y = mx + b \]
Again, but with dollar signs:
$$ y = mx + b $$
# Regarding $\vec g$ and its effects
Math in a heading
~~~~ {.haskell}
f x = length $ tail x
~~~~
$x + 1$
$e_{ik}$ in the statement the theorem about $V_k$
$**η = (-1)^{k(n-k)}sη$, where $**η$, is the Hodge star applied twice.
\[ a_1 \]
This is neither math nor italic
\[ a_2 \]
Support brackets with two backslashes, as do MultiMarkdown and Pandoc:
\\[
\Gamma(x) = \int_0^\infty t^{x-1}{\mathrm{e}}^{-t}\,{\mathrm{d}}
\\]
markdown-mode-2.3+154/tests/more-lists.text 0000664 0000000 0000000 00000001245 13217531627 0020606 0 ustar 00root root 0000000 0000000 Ordered, without paragraphs:
1. Foo
2. Bar
Unordered, with paragraphs:
* A list item.
With multiple paragraphs.
* Bar
Nested lists:
* Bubbles
1. bunk
2. bupkis
* BELITTLER
3. burper
* Abacus
* answer
* Cunning
A complex, multiply-nested list:
* Unordered stuff
with overhang
4. fourth nested
2. second nested
0. zeroth nested
* More unordered stuff
0. zeroth nested
2. second nested
4. fourth nested
Nested ordered lists:
1. first
0. zeroth nested
2. second nested
4. fourth nested
2. second
1. first nested
3. third nested
3. third
4. fourth
markdown-mode-2.3+154/tests/nested-list.text 0000664 0000000 0000000 00000001105 13217531627 0020736 0 ustar 00root root 0000000 0000000 - List level 1 item 1
- List level 1 item 2
Second paragraph of item 2
Nested pre block in item 2
Four spaces past the marker
Another paragraph of item 2
- List level 1 item 3
- List level 2 item 1
Four spaces from higher-level the marker.
More indentation in the same block
does not trigger a pre block!
Nested pre block
Four spaces past the previous marker
- List level 2 item 2
- List level 3 item 1
Nested pre block
markdown-mode-2.3+154/tests/outline-code.text 0000664 0000000 0000000 00000000300 13217531627 0021066 0 ustar 00root root 0000000 0000000 # Level one
* A list item
with some overhang
+ and a sublist
## Level two
~~~ {.bash}
#!/bin/bash
# In a code block, this shouldn't be a header
~~~
# Level one again
some body text
markdown-mode-2.3+154/tests/outline.text 0000664 0000000 0000000 00000001050 13217531627 0020161 0 ustar 00root root 0000000 0000000 Pre-header text.
# A top-level header
followed by some body text
## A second-level header
followed by some body text
### Third level ###
* A list item
* and another
with some overhang
+ and a sublist
with overhang
- And a third with a different marker
### Third level number two ###
### Level two again
followed by some body text
An underline-style header
=========================
With some text
And a level two underline header
--------------------------------
* With
* an unordered
* list
# Level one
foo
## Level two
bar
markdown-mode-2.3+154/tests/r-markdown-test.text 0000664 0000000 0000000 00000000474 13217531627 0021551 0 ustar 00root root 0000000 0000000 % Test example
% Mathieu Basille
% September 11, 2013
# First section
## And a sub-section
```{r sum}
2+2
```
Some text...
## Second sub-section
Some more text, and the faulty chunk with comments:
```{r comments}
2+2
## Wait, still 4?
```
And text you will never see again!
# Second section
More text...
markdown-mode-2.3+154/tests/syntax.text 0000664 0000000 0000000 00000066210 13217531627 0020041 0 ustar 00root root 0000000 0000000 Markdown: Syntax
================
* [Overview](#overview)
* [Philosophy](#philosophy)
* [Inline HTML](#html)
* [Automatic Escaping for Special Characters](#autoescape)
* [Block Elements](#block)
* [Paragraphs and Line Breaks](#p)
* [Headers](#header)
* [Blockquotes](#blockquote)
* [Lists](#list)
* [Code Blocks](#precode)
* [Horizontal Rules](#hr)
* [Span Elements](#span)
* [Links](#link)
* [Emphasis](#em)
* [Code](#code)
* [Images](#img)
* [Miscellaneous](#misc)
* [Backslash Escapes](#backslash)
* [Automatic Links](#autolink)
**Note:** This document is itself written using Markdown; you
can [see the source for it by adding '.text' to the URL][src].
[src]: /projects/markdown/syntax.text
* * *
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] [1], [atx] [2], [Textile] [3], [reStructuredText] [4], [Grutatext] [5], and [EtText] [6] -- the single biggest source of inspiration for Markdown's syntax is the format of plain text email. [1]: http://docutils.sourceforge.net/mirror/setext.html [2]: http://www.aaronsw.com/2002/atx/ [3]: http://textism.com/tools/textile/ [4]: http://docutils.sourceforge.net/rst.html [5]: http://www.triptico.com/software/grutatxt.html [6]: http://ettext.taint.org/doc/ 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. ``,
`