kramdown 0.6.0 → 0.7.0

data/bin/kramdown

@@ -36,10 +36,6 @@ OptionParser.new do |opts|
 
   opts.on("-i", "--input ARG", "Specify the input format: kramdown (default)") {|v| options[:input] = v}
   opts.on("-o", "--ouput ARG", "Specify the output format: html (default) or latex") {|v| format = v}
-  opts.on("-f", "--format ARG", "DEPRACATED: Specify the output format: html (default) or latex") do |v|
-    warn("DEPRECATED: This option will be removed in the next release, use --output instead")
-    format = v
-  end
 
   opts.on("-v", "--version", "Show the version of kramdown") do
     puts Kramdown::VERSION

data/doc/index.page

@@ -88,7 +88,7 @@ It is probably the fastest pure-Ruby Markdown converter available (February 2010
 faster than [Maruku] and about 10x faster than [BlueFeather].
 
 <p class="a-center">
-The latest version of kramdown is <b>0.6.0</b> and it was released on <b>2010-04-06</b>.
+The latest version of kramdown is <b>0.7.0</b> and it was released on <b>2010-05-07</b>.
 </p>
 
 [PHP Markdown Extra]: http://michelf.com/projects/php-markdown/extra/

data/doc/links.markdown

@@ -0,0 +1,4 @@
+[Maruku]: http://maruku.rubyforge.org
+[PHP Markdown Extra]: http://michelf.com/projects/php-markdown/extra/
+[Pandoc]: http://johnmacfarlane.net/pandoc/
+[jsMath]: http://www.math.union.edu/~dpvc/jsMath/

data/doc/news.page

@@ -13,8 +13,9 @@ sort_info: 30
 --- name:newsdata pipeline:erb
 <%
 context.content_node.tree.node_access[:alcn].select do |na,no|
-   na =~ /\/news\/.+/ && no.is_file?
+  na =~ /\/news\/.+/ && no.is_file?
 end.collect {|na,no| no}.sort.reverse.each do |node|
+  context.options['contentprocessor.kramdown.options'] = {:auto_id_prefix => node.lcn.tr('.', '-')}
 %>
 
 <div class='news-item'>

data/doc/quickref.page

@@ -33,40 +33,40 @@ Live browser view of example code
 
 ## Paragraphs
 
-{::kdlink:: #paragraphs part="paragraphs"}
+{kdlink: {oid: paragraphs, part: "paragraphs"}}
 
 Paragraphs are separated by one or more blank lines:
 
-{::kdexample:}
+{kdexample::}
 The first paragraph.
 
 Another paragraph
-{::kdexample:}
+{kdexample}
 
 Explicit line breaks in a paragraph can be made by using two spaces or two backslashes at the end of a line:
 
-{::kdexample:}
+{kdexample::}
 This is a paragraph  
 which contains a hard line break.
-{::kdexample:}
+{kdexample}
 
 
 ## Headers
 
-{::kdlink:: #headers part="headers"}
+{kdlink: {oid: headers, part: "headers"}}
 
 kramdown supports Setext style headers and atx style headers. A header must always be preceded by a
 blank line except at the beginning of the document:
 
-{::kdexample:}
+{kdexample::}
 First level header
 ==================
 
 Second level header
 -------------------
-{::kdexample:}
+{kdexample}
 
-{::kdexample:}
+{kdexample::}
 # H1 header
 
 ## H2 header
@@ -78,70 +78,68 @@ Second level header
 ##### H5 header
 
 ###### H6 header
-{::kdexample:}
+{kdexample}
 
 If you set the option `auto_ids` to `false` (for example, by using the `options` extension, see
-[Extension Blocks](#extension-blocks)), then the automatic header ID generation is turned off:
+[Extensions](#extensions)), then the automatic header ID generation is turned off:
 
-{::kdexample:}
-# A header with an ID
-
-{::options:: auto_ids="false"}
+{kdexample::}
+{:options auto_ids="false" /}
 
 # A header without an ID
-{::kdexample:}
+{kdexample}
 
 
 ## Blockquotes
 
-{::kdlink:: #blockquotes part="blockquotes"}
+{kdlink: {oid: blockquotes, part: "blockquotes"}}
 
 A blockquote is started using the `>` marker followed by an optional space; all following lines that
 are also started with the blockquote marker belong to the blockquote. You can use any block level
 elements inside a blockquote:
 
-{::kdexample:}
+{kdexample::}
 > A sample blockquote.
 > >Nested blockquotes are
 > >also possible.
 >
 > ## Headers work too
 > This is the outer quote again.
-{::kdexample:}
+{kdexample}
 
 
 ## Code Blocks
 
-{::kdlink:: #code-blocks part="code blocks"}
+{kdlink: {oid: code-blocks, part: "code blocks"}}
 
 kramdown supports two different code block styles. One uses lines indented with either four spaces
 or one tab whereas the other uses lines with tilde characters as delimiters -- therefore the content
 does not need to be indented:
 
-{::kdexample:}
+{kdexample::}
     This is a sample code block.
 
     Continued here.
-{::kdexample:}
+{kdexample}
 
-{::kdexample:}
+{kdexample::}
 ~~~~~~
 This is also a code block.
 ~~~
 Ending lines must have at least as
 many tildes as the starting line.
 ~~~~~~~~~~~~
-{::kdexample:}
+{kdexample}
 
 
 ## Horizontal Rules
 
-{::kdlink:: #horizontal-rules part="horizontal rules"}
+{kdlink: {oid: horizontal-rules, part: "horizontal rules"}}
 
 It is easy to insert a horizontal rule in kramdown: just use three or more asterisks, dashes or
 underscores, optionally separated by spaces or tabs, on an otherwise blank line:
 
-{::kdexample:}
+{kdexample::}
 * * *
 
 \---
@@ -149,28 +147,28 @@ underscores, optionally separated by spaces or tabs, on an otherwise blank line:
   _  _  _  _
 
 ---------------
-{::kdexample:}
+{kdexample}
 
 
 ## Lists
 
-{::kdlink:: #lists part="lists"}
+{kdlink: {oid: lists, part: "lists"}}
 
 kramdown supports ordered and unordered lists. Ordered lists are started by using a number followed
 by a period, a space and then the list item text. The content of a list item consists of block level
 elements. All lines which have the same indent as the text of the line with the list marker belong
 to the list item:
 
-{::kdexample:}
+{kdexample::}
 1. This is a list item
 2. And another item
 2. And the third one
    with additional. text
-{::kdexample:}
+{kdexample}
 
 As the content consists of block level elements you can do things like the following:
 
-{::kdexample:}
+{kdexample::}
 1.  This is a list item
 
     > with a blockquote
@@ -178,47 +176,47 @@ As the content consists of block level elements you can do things like the follo
     # And a header
 
 2.  Followed by another item
-{::kdexample:}
+{kdexample}
 
 Nested lists are also easy to create:
 
-{::kdexample:}
+{kdexample::}
 1. Item one
    1. sub item one
    2. sub item two
    3. sub item three
 2. Item two
-{::kdexample:}
+{kdexample}
 
 Lists can occur directly after other block level elements, however, there has to be at least one
 blank line if you want to follow a paragraph with a list:
 
-{::kdexample:}
+{kdexample::}
 This is a paragraph.
 1. This is NOT a list.
 
 1. This is a list!
-{::kdexample:}
+{kdexample}
 
 Unordered lists are started by using an asterisk, a dash or a plus sign (they can be mixed) and a
 space. Apart from that unordered lists follow the same rules as ordered lists:
 
-{::kdexample:}
+{kdexample::}
 * Item one
 + Item two
 - Item three
-{::kdexample:}
+{kdexample}
 
 ## Definition Lists
 
-{::kdlink:: #definition-lists part="definition lists"}
+{kdlink: {oid: definition-lists, part: "definition lists"}}
 
 A definition list works similar to a normal list and is used to associate definitions with terms.
 Definition lists are started when a normal paragraph is followed by a line starting with a colon and
 then the definition text. One term can have many definitions and multiple terms can have the same
 definition. Each line of the preceding paragraph is assumed to contain one term, for example:
 
-{::kdexample:}
+{kdexample::}
 term
 : definition
 : another definition
@@ -226,35 +224,35 @@ term
 another term
 and another term
 : and a definition for the term
-{::kdexample:}
+{kdexample}
 
 If you insert a blank line before a definition (note: there must only be one blank line between the
 terms and the first definition), the definition will be wrapped in a paragraph:
 
-{::kdexample:}
+{kdexample::}
 term
 
 : definition
 : definition
-{::kdexample:}
+{kdexample}
 
 Each term can be styled using span level elements and each definition is parsed as block level
 elements, i.e. you can use any block level in a definition. Just use the same indent for the lines
 following the definition line:
 
-{::kdexample:}
+{kdexample::}
 This *is* a term
 
 : This will be a para
   > a blockquote
 
   # A header
-{::kdexample:}
+{kdexample}
 
 
 ## Tables
 
-{::kdlink:: #tables part="tables"}
+{kdlink: {oid: tables, part: "tables"}}
 
 kramdown supports a syntax for creating simple tables. A line starting with a pipe character (`|`)
 starts a table row. However, if the pipe characters is immediately followed by a dash (`-`), a
@@ -263,12 +261,12 @@ separator line is created. Separator lines are used to split the table header fr
 pipe character is followed by an equal sign (`=`), the tables rows below it are part of the table
 footer.
 
-{::kdexample:}
+{kdexample::}
 | A simple | table |
 | with multiple | lines|
-{::kdexample:}
+{kdexample}
 
-{::kdexample:}
+{kdexample::}
 | Header1 | Header2 | Header3 |
 |:--------|:-------:|--------:|
 | cell1   | cell2   | cell3   |
@@ -279,12 +277,12 @@ footer.
 |=====
 | Foot1   | Foot2   | Foot3
 {: rules="groups"}
-{::kdexample:}
+{kdexample}
 
 
 ## HTML elements
 
-{::kdlink:: #html-blocks part="HTML blocks"}
+{kdlink: {oid: html-blocks, part: "HTML blocks"}}
 
 kramdown allows you to use block level HTML tags (`div`, `p`, `pre`, ...) to markup whole blocks of
 text -- just start a line with a block level HTML tag. kramdown syntax is normally not processed
@@ -292,48 +290,48 @@ inside an HTML tag but this can be changed with the `parse_block_html` option. I
 set to `true`, then the content of a block level HTML tag is parsed by kramdown either as block
 level or span level text, depending on the tag:
 
-{::kdexample:}
+{kdexample::}
 <div style="float: right">
 Something that stays right and is not wrapped in a para.
 </div>
-{::options:: parse_block_html="true"}
+{options: parse_block_html="true"}
 <div>
 This is wrapped in a para.
 </div>
 <p>
 This can contain only *span* level elements.
 </p>
-{::kdexample:}
+{kdexample}
 
 
 ## Block Attributes
 
-{::kdlink:: #block-inline-attribute-lists part="block IALs"}
-{::kdlink:: #attribute-list-definitions part="ALDs"}
+{kdlink: {oid: block-inline-attribute-lists, part: "block IALs"}}
+{kdlink: {oid: attribute-list-definitions, part: "ALDs"}}
 
 You can assign any attribute to a block level element. Just directly follow the block with a *block
 inline attribute list* (or short: block IAL). A block IAL consists of a left curly brace, followed
 by a colon, the attribute definitions and a right curly brace. Here is a simple example which sets the
 `title` attribute of a block quote:
 
-{::kdexample:}
+{kdexample::}
 > A nice blockquote
 {: title="Blockquote title"}
-{::kdexample:}
+{kdexample}
 
 As one often wants to set one or more CSS classes on an element, there is an easy shortcut:
 
-{::kdexample:}
+{kdexample::}
 > A nice blockquote
 {: .class1 .class2}
-{::kdexample:}
+{kdexample}
 
 A shortcut for setting the ID is also provided. Just prefix the ID with a hash symbol:
 
-{::kdexample:}
+{kdexample::}
 > A nice blockquote
 {: #with-an-id}
-{::kdexample:}
+{kdexample}
 
 Sometimes one wants to use the same attributes for many elements. kramdown allows you to define the
 attributes in one place with an *attribute list definition* (or short: ALD) and just reference this
@@ -341,61 +339,57 @@ definition in a block IAL. An ALD has the same structure as a block IAL but the
 replace with a colon, the reference name and another colon. By just using the reference name as-is
 in a block IAL, one can include the attributes of the referenced ALD:
 
-{::kdexample:}
+{kdexample::}
 {:refdef: .c1 #id .c2 title="title"}
 paragraph
 {: refdef}
-{::kdexample:}
+{kdexample}
 
 The order in a block IAL or ALD is important because later defined attributes overwrite (with the
 exception of the shortcut for CSS classes) prior defined attributes:
 
-{::kdexample:}
+{kdexample::}
 {:refdef: .c1 #id .c2 title="title"}
 paragraph
 {: refdef .c3 title="t" #para}
-{::kdexample:}
+{kdexample}
 
 
-## Extension Blocks
+## Extensions
 
-{::kdlink:: #extension-blocks part="extension blocks"}
+{kdlink: {oid: extensions, part: "extensions"}}
 
-Extension blocks can be used to add custom behaviour to kramdown. For more information on how to do
-this have a look at the [API documentation]({relocatable: /rdoc/index.html}). kramdown comes with
-some built-in extensions for ignoring text (i.e. treating text as comment), for inserting arbitrary
-text into the output and for setting kramdown options.
+kramdown provides some less used functionality through a common syntax. This will allow the easy
+addition of other extensions if need arises. Currently, there are extensions for ignoring text (i.e.
+treating text as comment), for inserting arbitrary text as-is into the output and for setting
+kramdown options.
 
 Here is an example that shows how to insert comments into text:
 
-{::kdexample:}
+{kdexample::}
 This is a paragraph
-{::comment:}
+{:comment}
 This is a comment which is
 completely ignored.
-{::comment:}
+{:/comment}
 ... paragraph continues here.
 
-{::nomarkdown:}
-This is not parsed *by* kramdown
-{::nomarkdown:}
-{::kdexample:}
+Extensions can also be used
+inline {:nomarkdown}**see**{:/}!
+{kdexample}
 
-As one can see from the above example, the syntax for extension blocks is virtually the same as for
-block IALs and ALDs, except that the colon of a block IAL has to be replaced by two colons, the name
-of the extension and then one or two colons. If one colon is used, it means that the extension has
-body text and continues until a matching ending line (as in the example above). If two colons are
-used, then the extension does not have a body, for example:
+As one can see from the above example, the syntax for extensions is nearly identical to that of
+ALDs. However, there is no trailing colon after the extension name and the extension end tag needs a
+slash between the colon and the extension name. One can also use the short form of the end tag, i.e.
+`{:/}`. Attribute definitions can be specified on the start tag by separating them with a space from
+the extension name. Also, if the extension does not have a body, there needs to be a slash right
+before the closing brace:
 
-{::kdexample:}
-# Header with id
-{::options:: auto_ids="false"}
+{kdexample::}
+{:options auto_ids="false" /}
 
 # Header without id
-{::options:: auto_ids="true"}
-
-# Header with id
-{::kdexample:}
+{kdexample}
 
 
 
@@ -404,115 +398,115 @@ used, then the extension does not have a body, for example:
 
 ## Emphasis
 
-{::kdlink:: #emphasis part="emphasis"}
+{kdlink: {oid: emphasis, part: "emphasis"}}
 
 Emphasis can be added to text by surrounding the text with either asterisks or underscores:
 
-{::kdexample:}
+{kdexample::}
 This is *emphasized*,
 _this_ too!
-{::kdexample:}
+{kdexample}
 
 Strong emphasis can be done by doubling the delimiters:
 
-{::kdexample:}
+{kdexample::}
 This is **strong**,
 __this__ too!
-{::kdexample:}
+{kdexample}
 
 The form with the asterisks can also be used to markup parts of words:
 
-{::kdexample:}
+{kdexample::}
 This w**ork**s as expected!
-{::kdexample:}
+{kdexample}
 
 
 ## Links and Images
 
-{::kdlink:: #links-and-images part="links and images"}
+{kdlink: {oid: links-and-images, part: "links and images"}}
 
 A simple link can be created by surrounding the text with square brackets and the link URL with
 parentheses:
 
-{::kdexample:}
+{kdexample::}
 A [link](http://kramdown.rubyforge.org)
 to the kramdown homepage.
-{::kdexample:}
+{kdexample}
 
 You can also add title information to the link:
 
-{::kdexample:}
+{kdexample::}
 A [link](http://kramdown.rubyforge.org "hp")
 to the homepage.
-{::kdexample:}
+{kdexample}
 
 There is another way to create links which does not interrupt the text flow. The URL and title are
 defined using a reference name and this reference name is then used in square brackets instead of
 the link URL:
 
-{::kdexample:}
+{kdexample::}
 A [link][kramdown hp]
 to the homepage.
 
 [kramdown hp]: http://kramdown.rubyforge.org "hp"
-{::kdexample:}
+{kdexample}
 
 If the link text itself is the reference name, the second set of square brackets can be omitted:
 
-{::kdexample:}
+{kdexample::}
 A link to the [kramdown hp].
 
 [kramdown hp]: http://kramdown.rubyforge.org "hp"
-{::kdexample:}
+{kdexample}
 
 Images can be created in a similar way: just use an exclamation mark before the square brackets. The
 link text will become the alternative text of the image and the link URL specifies the image source:
 
-{::kdexample:}
+{kdexample::}
 An image: ![gras](img/image.jpg)
-{::kdexample:}
+{kdexample}
 
 
 ## Inline Code
 
-{::kdlink:: #code-spans part="code spans"}
+{kdlink: {oid: code-spans, part: "code spans"}}
 
 Text phrases can be easily marked up as code by surrounding them with backticks:
 
-{::kdexample:}
+{kdexample::}
 Use `Kramdown::Document.new(text).to_html`
 to convert the `text` in kramdown
 syntax to HTML.
-{::kdexample:}
+{kdexample}
 
 If you want to use literal backticks in your code, just use two or more backticks as delimiters. The
 space right after the beginning delimiter and the one right before the closing delimiter are ignore:
 
-{::kdexample:}
+{kdexample::}
 Use backticks to markup code,
 e.g. `` `code` ``.
-{::kdexample:}
+{kdexample}
 
 
 ## Footnotes
 
-{::kdlink:: #footnotes part="footnotes"}
+{kdlink: {oid: footnotes, part: "footnotes"}}
 
 Footnotes can easily be used in kramdown. Just set a footnote marker (consists of square brackets
 with a caret and the footnote name inside) in the text and somewhere else the footnote definition (which
 basically looks like a reference link definition):
 
-{::kdexample:}
+{kdexample::}
 This is a text with a
 footnote[^1].
 
 [^1]: And here is the definition.
-{::kdexample:}
+{kdexample}
 
 The footnote definition can contain any block level element, all lines following a footnote
 definition indented with four spaces or one tab belong to the definition:
 
-{::kdexample:}
+{kdexample::}
 This is a text with a
 footnote[^2].
 
@@ -520,32 +514,47 @@ footnote[^2].
     And here is the definition.
 
     > With a quote!
-{::kdexample:}
+{kdexample}
 
 As can be seen above the footnote name is only used for the anchors and the numbering is done
 automatically in document order.
 
 
+## Abbreviations
+
+{kdlink: {oid: abbreviations, part: "abbreviations"}}
+
+Abbreviations will work out of the box once you add an abbreviation definition. So you can just
+write the text and add the definitions later on.
+
+{kdexample::}
+This is an HTML
+example.
+
+*[HTML]: Hyper Text Markup Language
+{kdexample}
+
+
 ## HTML Elements
 
-{::kdlink:: #html-spans part="HTML spans"}
+{kdlink: {oid: html-spans, part: "HTML spans"}}
 
 HTML is not only supported on the block level but also on the span level:
 
-{::kdexample:}
+{kdexample::}
 This is <span style="color: red">written in
 red</span>.
-{::kdexample:}
+{kdexample}
 
 
 ## Inline Attributes
 
-{::kdlink:: #span-inline-attribute-lists part="span IALs"}
+{kdlink: {oid: span-inline-attribute-lists, part: "span IALs"}}
 
 As with a block level element you can assign any attribute to a span level elements using a *span
 inline attribute list* (or short: span IAL). A span IAL has the same syntax as a block IAL and must
 immediately follow the span level element:
 
-{::kdexample:}
+{kdexample::}
 This is *red*{: style="color: red"}.
-{::kdexample:}
+{kdexample}