Bumping to 0.3.4 for the next point release.
Adding escape characters to word so that template text can include "|" and "=".
Adding escaped characters and tests, small optimization.

Escaped characters only apply inside templates.  I think this breaks \| outside
of templates though.  Ugh.
Reverting print statement in lib/marker.rb.
Updating calls to template functions to include options.

Options should be passed to template calls so they can be used, not including
it at first was an oversight.

Options passed to template functions also includes :tree now, which is the
parse tree for the template.  This allows template functions to access the raw
source for the markup, which is needed right now to support syntax
highlighting.
Adding code for a potential fix to the tab bug.

It's currently commented out, so this doesn't change anything.
Updating Rakefile for template changes.
Templates: Added :raw format and format changing.

Now the render options can specify the format for a template's arguments.  This
allows special templates like syntax highlighting to avoid rendering arguments
entirely (by setting options[:template_formats][:template_name] = :raw) so that
the arguments can be rendered by the template itself without side-effects like
link footnotes.  The :raw format simply returns the original parsed text of
arguments.

Another change in this commit is to remove the :tree option that was added a
few commits ago.  It was a bad idea, although necessary in some cases.  I
think, however, for those cases it is better to monkey-patch something in.
Updating the templates tests to include options.

In previous commits, the options were not part of the default render because
they included a :tree option that was the parse tree for the template.  This
was just a hack, so it is now removed and options should be verified in the
tests as well.
Updated to allow line-anchored markup in templates.

Previously, newlines were allowed inside templates, but line-anchored markup
(lists, verbatim, etc.) was not possible.  These changes make it possible to
have line anchored markup render correctly when inside templates.

The changes move delimiters for templates ("|" and "}}")  up to the block
level, along with list, text, and others.  This way, the delimiters will still
match as text when they are not part of a template.  However, they are easily
removed for the new arg_markup, arg_block, etc. rules that match more markup
inside templates, without missing the template's delimiters.

These changes should help when writing templates that don't use formatted
parameters, like syntax highlighting templates.  Those templates will now have
access to the original whitespace that was previously stripped by the rule,
since whitespace rules around template arguments were removed--the markup rules
handle whitespace themselves.

The line rule is now gone.  It was merged into the block rule (and now
arg_block), which makes more sense since line contained a couple of multi-line
rules.  It was intended to mean line-anchored, but wasn't really necesary and
it made sense to remove it.

Next problems to solve:
1. | and }}, when caught at the block level, will be rendered as paragraphs
2. In general, html paragraphs will need to be reworked
3. Templates that contain "|" as content will be difficult to write
Updated template to produce no named args for :raw.

One problem with templates is that if "|" is used in the content, it gets
removed and interpreted as an argument delimiter.  Raw formatted template
arguments are supposed to be a way to increase the flexibility of templates by
making the "raw" parsed text available to templates that wanted to do something
different with it.  For example, syntax highlighting needs to get
the raw content to correctly display code:
 {{ ruby |
 names.each do |name='(unknown)'|
   puts "hello, #{name}!"
 end
 }}

Before this commit, only the value of named parameters was given in raw form,
which meant that in cases like the above, the text could not be reconstructed.
This commit changes the raw format so that all parameters, named and
positional, are given in order as their original text values.
Allowing newlines before keyword args in templates.

This changes the rule for keyword arguments, substituting aws for ws in the
beginning.  This is to allow keyword arguments to be used on new lines.
Keyword arguments just need to have the keyword and the "=" on one line.

This is now allowed:
{{ template name |
keyword = some markup
}}
Adding .gitignore.
Adding a compromise for template embedding.

Templates can be embedded as inline or block style--just like html.  Inline
style is for options like fixed-width text that can be embedded in a paragraph
without needing a change in the html structure.  Block style is for things that
should not be embedded in paragraphs.  This is now necessary because it is
possible to have markup, not just text, inside a template.

Unfortunately, it is difficult to split paragraphs when a template renders as a
block.  It is also difficult to detect when a template renders as a block,
since anything can be returned by templates when they are rendered.  The
compromise is to assume that templates that contain block values will render as
blocks (since they must) and that templates with only inline values will render
inline.  Templates that contain block arguments are wrapped in divs to avoid
encapsulation problems (paragraphs cannot directly contain paragraphs) and
inline templates are not wrapped.

Text changes:
* Added TextBlock for text blocks that are not paragraphs (in templates)

Language changes:
* Added a paragraph rule that wraps text blocks where they should be
* Changed text rules to use TextBlock
* Similar changes for unsafe_ rules
* Added inline text rules back to templates
* Separated inline and block arguments using classes

Template changes:
* Added Argument subclasses InlineArgument and BlockArgument
* Added block? methods to arguments
* Added block? method to arg lists, true if any arg is a block
* Added block? method to templates, true if the arg list is
* Added block handling to html rendering, which adds a div to block templates
Fixing bug: unsafe_text wrapped in a paragraph.

Unsafe text wrapped in a paragraph could not be accessed because there was no
'text' attribute.  This fix renames unsafe_text to text, which matches safe
text.
Adding no_wrap? check to paragraphs.

no_wrap? determines whether a paragraph should render a block of text wrapped
in <p> for html.  This inspects the parse tree to see if the block of text is
really just a single template.  If it is a lone template, then it should not be
wrapped since it is most likely a block template.  This is not always the case,
but it should be often enough that it is a good assumption to make.

This ensures that this is not incorrectly wrapped in a paragraph:

{{ floating text box |* list of stuff }}

However, this inline template will be rendered incorrectly, which is part of
the compromise:

{{tt|inline fixed-width text}}

This is a rare situation.
Fixing the gemspec dependency on treetop.

Should be ~> 1.4 instead of >= 1.4.2
Updating the langauge grammar to fix template bugs.

Major changes:
1. blocks and arg_blocks no longer match blanks, instead blocks are separated
   by at least one newline in the grammar. Because no blank lines are matched
   as blocks, now markup sections (like paragraphs) in HTML are only separated
   by a single newline. This also removes all inline functions!

2. markup inside template arguments must begin with a newline. Now unsafe_text
   is used to match the first line, if it is present.

3. A new top-level rule, document, was introduced to do document setup and
   append any footnotes. This is so markup blocks inside templates do not add
   footnotes when they are present and so that newlines are handled correctly.

Updating markup.rb for grammar changes:
* Introduced the Document class
* Separated to_html and to_s in Markup between Markup and Document
* Changed to_s to insert two newlines to separate Markup paragraphs, because
  all newlines between blocks are compacted.
Adding all updated, passing tests.

Added a helper method to the helper, but I think it needs to be improved to
work as a proper assertion before porting all the tests to it.
Fixing a minor bug with plain text arguments.

Also adding a lot of passing tests.