## DESCRIPTION
Mustache is a logic-less templating system for HTML, config files,
anything.
The `mustache` command processes a Mustache template preceded by YAML
frontmatter from standard input and prints one or more documents to
standard output.
YAML frontmatter beings with `---` on a single line, followed by YAML,
ending with another `---` on a single line, e.g.
---
names: [ {name: chris}, {name: mark}, {name: scott} ]
---
If you are unfamiliar with YAML, it is a superset of JSON. Valid JSON
should work fine.
After the frontmatter should come any valid Mustache template. See
mustache(5) for an overview of Mustache templates.
For example:
{{#names}}
Hi {{name}}!
{{/names}}
Now let's combine them.
$ cat data.yml
---
names: [ {name: chris}, {name: mark}, {name: scott} ]
---
$ cat template.mustache
{{#names}}
Hi {{name}}!
{{/names}}
$ cat data.yml template.mustache | mustache
Hi chris!
Hi mark!
Hi scott!
If you provide multiple YAML documents (as delimited by `---`), your
template will be rendered multiple times. Like a mail merge.
For example:
$ cat data.yml
---
name: chris
---
name: mark
---
name: scott
---
$ cat template.mustache
Hi {{name}}!
$ cat data.yml template.mustache | mustache
Hi chris!
Hi mark!
Hi scott!
## OPTIONS
By default `mustache` will try to render a Mustache template using the
YAML frontmatter you provide. It can do a few other things, however.
* `-c`, `--compile`:
Print the compiled Ruby version of a given template. This is the
code that is actually used when rendering a template into a
string. Useful for debugging but only if you are familiar with
Mustache's internals.
* `-t`, `--tokens`:
Print the tokenized form of a given Mustache template. This can be
used to understand how Mustache parses a template. The tokens are
handed to a generator which compiles them into a Ruby
string. Syntax errors and confused tags, therefor, can probably be
identified by examining the tokens produced.
## INSTALLATION
If you have RubyGems installed:
gem install mustache
## EXAMPLES
$ mustache data.yml template.mustache
$ cat data.yml | mustache - template.mustache
$ mustache -c template.mustache
$ cat <
mustache-0.99.4/man/mustache.1.html 0000644 0001750 0001750 00000012607 11643306253 017006 0 ustar virtual virtual
mustache(1) -- Mustache processor
mustache(1)
- mustache(1)
- Mustache Manual
- mustache(1)
NAME
mustache -- Mustache processor
SYNOPSIS
mustache <YAML> <FILE>
mustache --compile <FILE>
mustache --tokens <FILE>
DESCRIPTION
Mustache is a logic-less templating system for HTML, config files,
anything.
The mustache command processes a Mustache template preceded by YAML
frontmatter from standard input and prints one or more documents to
standard output.
YAML frontmatter beings with --- on a single line, followed by YAML,
ending with another --- on a single line, e.g.
---
names: [ {name: chris}, {name: mark}, {name: scott} ]
---
If you are unfamiliar with YAML, it is a superset of JSON. Valid JSON
should work fine.
After the frontmatter should come any valid Mustache template. See
mustache(5) for an overview of Mustache templates.
For example:
{{#names}}
Hi {{name}}!
{{/names}}
Now let's combine them.
$ cat data.yml
---
names: [ {name: chris}, {name: mark}, {name: scott} ]
---
$ cat template.mustache
{{#names}}
Hi {{name}}!
{{/names}}
$ cat data.yml template.mustache | mustache
Hi chris!
Hi mark!
Hi scott!
If you provide multiple YAML documents (as delimited by ---), your
template will be rendered multiple times. Like a mail merge.
For example:
$ cat data.yml
---
name: chris
---
name: mark
---
name: scott
---
$ cat template.mustache
Hi {{name}}!
$ cat data.yml template.mustache | mustache
Hi chris!
Hi mark!
Hi scott!
OPTIONS
By default mustache will try to render a Mustache template using the
YAML frontmatter you provide. It can do a few other things, however.
-c, --compilePrint the compiled Ruby version of a given template. This is the
code that is actually used when rendering a template into a
string. Useful for debugging but only if you are familiar with
Mustache's internals.
-t, --tokensPrint the tokenized form of a given Mustache template. This can be
used to understand how Mustache parses a template. The tokens are
handed to a generator which compiles them into a Ruby
string. Syntax errors and confused tags, therefor, can probably be
identified by examining the tokens produced.
INSTALLATION
If you have RubyGems installed:
gem install mustache
EXAMPLES
$ mustache data.yml template.mustache
$ cat data.yml | mustache - template.mustache
$ mustache -c template.mustache
$ cat <<data | ruby mustache - template.mustache
---
name: Bob
age: 30
---
data
COPYRIGHT
Mustache is Copyright (C) 2009 Chris Wanstrath
Original CTemplate by Google
SEE ALSO
mustache(5), mustache(7), gem(1),
http://mustache.github.com/
mustache-0.99.4/man/mustache.5.html 0000644 0001750 0001750 00000024720 11643306253 017011 0 ustar virtual virtual
mustache(5) -- Logic-less templates.
mustache(5)
- mustache(5)
- Mustache Manual
- mustache(5)
NAME
mustache -- Logic-less templates.
SYNOPSIS
A typical Mustache template:
Hello {{name}}
You have just won {{value}} dollars!
{{#in_ca}}
Well, {{taxed_value}} dollars, after taxes.
{{/in_ca}}
Given the following hash:
{
"name": "Chris",
"value": 10000,
"taxed_value": 10000 - (10000 * 0.4),
"in_ca": true
}
Will produce the following:
Hello Chris
You have just won 10000 dollars!
Well, 6000.0 dollars, after taxes.
DESCRIPTION
Mustache can be used for HTML, config files, source code -
anything. It works by expanding tags in a template using values
provided in a hash or object.
We call it "logic-less" because there are no if statements, else
clauses, or for loops. Instead there are only tags. Some tags are
replaced with a value, some nothing, and others a series of
values. This document explains the different types of Mustache tags.
TAG TYPES
Tags are indicated by the double mustaches. {{person}} is a tag, as
is {{#person}}. In both examples, we'd refer to person as the key
or tag key. Let's talk about the different types of tags.
Variables
The most basic tag type is the variable. A {{name}} tag in a basic
template will try to find the name key in the current context. If
there is no name key, nothing will be rendered.
All variables are HTML escaped by default. If you want to return
unescaped HTML, use the triple mustache: {{{name}}}.
You can also use & to unescape a variable: {{& name}}. This may be
useful when changing delimiters (see "Set Delimiter" below).
By default a variable "miss" returns an empty string. This can usually
be configured in your Mustache library. The Ruby version of Mustache
supports raising an exception in this situation, for instance.
Template:
* {{name}}
* {{age}}
* {{company}}
* {{{company}}}
Hash:
{
"name": "Chris",
"company": "<b>GitHub</b>"
}
Output:
* Chris
*
* <b>GitHub</b>
* <b>GitHub</b>
Sections
Sections render blocks of text one or more times, depending on the
value of the key in the current context.
A section begins with a pound and ends with a slash. That is,
{{#person}} begins a "person" section while {{/person}} ends it.
The behavior of the section is determined by the value of the key.
False Values or Empty Lists
If the person key exists and has a value of false or an empty
list, the HTML between the pound and slash will not be displayed.
Template:
Shown.
{{#nothin}}
Never shown!
{{/nothin}}
Hash:
{
"person": true,
}
Output:
Shown.
Non-Empty Lists
If the person key exists and has a non-false value, the HTML between
the pound and slash will be rendered and displayed one or more times.
When the value is a non-empty list, the text in the block will be
displayed once for each item in the list. The context of the block
will be set to the current item for each iteration. In this way we can
loop over collections.
Template:
{{#repo}}
<b>{{name}}</b>
{{/repo}}
Hash:
{
"repo": [
{ "name": "resque" },
{ "name": "hub" },
{ "name": "rip" },
]
}
Output:
<b>resque</b>
<b>hub</b>
<b>rip</b>
Lambdas
When the value is a callable object, such as a function or lambda, the
object will be invoked and passed the block of text. The text passed
is the literal block, unrendered. {{tags}} will not have been expanded
- the lambda should do that on its own. In this way you can implement
filters or caching.
Template:
{{#wrapped}}
{{name}} is awesome.
{{/wrapped}}
Hash:
{
"name": "Willy",
"wrapped": function() {
return function(text) {
return "<b>" + render(text) + "</b>"
}
}
}
Output:
<b>Willy is awesome.</b>
Non-False Values
When the value is non-false but not a list, it will be used as the
context for a single rendering of the block.
Template:
{{#person?}}
Hi {{name}}!
{{/person?}}
Hash:
{
"person?": { "name": "Jon" }
}
Output:
Hi Jon!
Inverted Sections
An inverted section begins with a caret (hat) and ends with a
slash. That is {{^person}} begins a "person" inverted section while
{{/person}} ends it.
While sections can be used to render text one or more times based on the
value of the key, inverted sections may render text once based
on the inverse value of the key. That is, they will be rendered
if the key doesn't exist, is false, or is an empty list.
Template:
{{#repo}}
<b>{{name}}</b>
{{/repo}}
{{^repo}}
No repos :(
{{/repo}}
Hash:
{
"repo": []
}
Output:
No repos :(
Comments
Comments begin with a bang and are ignored. The following template:
<h1>Today{{! ignore me }}.</h1>
Will render as follows:
<h1>Today.</h1>
Comments may contain newlines.
Partials
Partials begin with a greater than sign, like {{> box}}.
Partials are rendered at runtime (as opposed to compile time), so
recursive partials are possible. Just avoid infinite loops.
They also inherit the calling context. Whereas in ERB you may have
this:
<%= partial :next_more, :start => start, :size => size %>
Mustache requires only this:
{{> next_more}}
Why? Because the next_more.mustache file will inherit the size and
start methods from the calling context.
In this way you may want to think of partials as includes, or template
expansion, even though it's not literally true.
For example, this template and partial:
base.mustache:
<h2>Names</h2>
{{#names}}
{{> user}}
{{/names}}
user.mustache:
<strong>{{name}}</strong>
Can be thought of as a single, expanded template:
<h2>Names</h2>
{{#names}}
<strong>{{name}}</strong>
{{/names}}
Set Delimiter
Set Delimiter tags start with an equal sign and change the tag
delimiters from {{ and }} to custom strings.
Consider the following contrived example:
* {{default_tags}}
{{=<% %>=}}
* <% erb_style_tags %>
<%={{ }}=%>
* {{ default_tags_again }}
Here we have a list with three items. The first item uses the default
tag style, the second uses erb style as defined by the Set Delimiter
tag, and the third returns to the default style after yet another Set
Delimiter declaration.
According to ctemplates, this "is useful for languages like TeX, where
double-braces may occur in the text and are awkward to use for
markup."
Custom delimiters may not contain whitespace or the equals sign.
COPYRIGHT
Mustache is Copyright (C) 2009 Chris Wanstrath
Original CTemplate by Google
SEE ALSO
mustache(1), mustache(7),
http://mustache.github.com/
mustache-0.99.4/test/ 0000755 0001750 0001750 00000000000 11643306253 014346 5 ustar virtual virtual mustache-0.99.4/test/autoloading_test.rb 0000644 0001750 0001750 00000002563 11643306253 020246 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__)
require 'helper'
module TestViews; end
class AutoloadingTest < Test::Unit::TestCase
def setup
Mustache.view_path = File.dirname(__FILE__) + '/fixtures'
end
def test_autoload
klass = Mustache.view_class(:Comments)
assert_equal Comments, klass
end
def test_autoload_lowercase
klass = Mustache.view_class(:comments)
assert_equal Comments, klass
end
def test_autoload_nil
klass = Mustache.view_class(nil)
assert_equal Mustache, klass
end
def test_autoload_empty_string
klass = Mustache.view_class('')
assert_equal Mustache, klass
end
def test_namespaced_autoload
Mustache.view_namespace = TestViews
klass = Mustache.view_class('Namespaced')
assert_equal TestViews::Namespaced, klass
assert_equal <<-end_render.strip, klass.render
Dragon < Tiger
end_render
end
def test_folder_autoload
assert_equal TestViews::Namespaced, Mustache.view_class('test_views/namespaced')
end
def test_namespaced_partial_autoload
Mustache.view_namespace = TestViews
klass = Mustache.view_class(:namespaced_with_partial)
assert_equal TestViews::NamespacedWithPartial, klass
assert_equal <<-end_render.strip, klass.render
My opinion: Again, Victory!
end_render
end
def test_bad_constant_name
assert_equal Mustache, Mustache.view_class(404)
end
end
mustache-0.99.4/test/template_test.rb 0000644 0001750 0001750 00000001031 11643306253 017540 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__)
require 'helper'
class TemplateTest < Test::Unit::TestCase
def test_compile
assert_equal %("foo"), Mustache::Template.new("foo").compile
end
def test_compile_with_source
assert_equal %("bar"), Mustache::Template.new("foo").compile("bar")
end
def test_token
assert_equal [:multi, [:static, "foo"]], Mustache::Template.new("foo").tokens
end
def test_token_with_source
assert_equal [:multi, [:static, "bar"]], Mustache::Template.new("foo").tokens("bar")
end
end
mustache-0.99.4/test/helper.rb 0000644 0001750 0001750 00000000231 11643306253 016146 0 ustar virtual virtual require 'test/unit'
$LOAD_PATH.unshift File.dirname(__FILE__) + '/fixtures'
Dir[File.dirname(__FILE__) + '/fixtures/*.rb'].each do |f|
require f
end
mustache-0.99.4/test/partial_test.rb 0000644 0001750 0001750 00000007044 11643306253 017373 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__)
require 'helper'
class PartialTest < Test::Unit::TestCase
def test_view_partial
assert_equal <<-end_partial.strip, PartialWithModule.render
Welcome
Hello Bob
You have just won $100000!
Fair enough, right?
end_partial
end
def test_partial_with_slashes
klass = Class.new(Mustache)
klass.template = '{{> test/fixtures/inner_partial}}'
view = klass.new
view[:title] = 'success'
assert_equal "Again, success!", view.render
end
def test_view_partial_inherits_context
klass = Class.new(TemplatePartial)
view = klass.new
view.template_path = File.dirname(__FILE__) + '/fixtures'
view[:titles] = [{:title => :One}, {:title => :Two}]
view.template = <<-end_template
Context Test
{{#titles}}
- {{>inner_partial}}
{{/titles}}
end_template
assert_equal <<-end_partial, view.render
Context Test
end_partial
end
def test_view_partial_inherits_context_of_class_methods
klass = Class.new(TemplatePartial)
klass.template_path = File.dirname(__FILE__) + '/fixtures'
klass.send(:define_method, :titles) do
[{:title => :One}, {:title => :Two}]
end
view = klass.new
view.template = <<-end_template
Context Test
{{#titles}}
- {{>inner_partial}}
{{/titles}}
end_template
assert_equal <<-end_partial, view.render
Context Test
end_partial
end
def test_template_partial
assert_equal <<-end_partial.strip, TemplatePartial.render
Welcome
Again, Welcome!
end_partial
end
def test_template_partial_with_custom_extension
partial = Class.new(TemplatePartial)
partial.template_extension = 'txt'
partial.template_path = File.dirname(__FILE__) + '/fixtures'
assert_equal <<-end_partial.strip, partial.render.strip
Welcome
-------
## Again, Welcome! ##
end_partial
end
def test_recursive_paritals
assert_equal <<-end_partial, Recursive.render
It works!
end_partial
end
def test_crazy_recursive_partials
assert_equal <<-end_partial.strip, CrazyRecursive.render
end_partial
end
def test_partials_use_proper_context
assert_equal "OuterThing OuterThing", OuterThing.render('{{name}} {{> p}}')
assert_equal "InnerThing InnerThing", InnerThing.render('{{name}} {{> p}}')
assert_equal "OuterThing InnerThing InnerThing",
OuterThing.render('{{name}} {{#inner}}{{name}} {{> p}}{{/inner}}')
end
def test_partials_render_returned_strings
assert_equal "ok", MiddleThing.render('{{> some_partial }}')
end
end
class InnerThing < Mustache
def partial(p) self.class end
def name; self.class end
end
class OuterThing < Mustache
def inner
InnerThing.new
end
def partial(p) self.class end
def name; self.class end
end
class MiddleThing < Mustache
def partial(name) "{{#{name}}}" end
def some_partial; "ok" end
end
mustache-0.99.4/test/mustache_test.rb 0000644 0001750 0001750 00000037177 11643306253 017562 0 ustar virtual virtual # -*- coding: utf-8 -*-
$LOAD_PATH.unshift File.dirname(__FILE__)
require 'helper'
class MustacheTest < Test::Unit::TestCase
def test_instance_render
klass = Class.new(Mustache)
klass.template = "Hi {{thing}}!"
assert_equal "Hi world!", klass.render(:thing => :world)
assert_equal "Nice.", klass.render("{{compliment}}.", :compliment => "Nice")
assert_equal <<-end_simple, Simple.new.render(:name => "yo", :in_ca => false)
Hello yo
You have just won $10000!
end_simple
end
def test_passenger
assert_equal <<-end_passenger, Passenger.to_text
ServerName example.com
DocumentRoot /var/www/example.com
RailsEnv production
end_passenger
end
def test_complex_view
assert_equal <<-end_complex, ComplexView.render
Colors
end_complex
end
def test_nested_objects
assert_equal <<-end_complex, NestedObjects.render
Colors
end_complex
end
def test_single_line_sections
html = %()
instance = Mustache.new
instance.template = html
instance[:no_flash] = true
assert_equal %Q'
', instance.render
end
def test_strings_as_sections_do_not_enumerate
instance = Mustache.new
instance[:contact] = "Call 1-888-FLOWERS\nAsk for Johnson."
instance.template = "{{#contact}}
{{contact}}
{{/contact}}"
assert_equal "Call 1-888-FLOWERS\nAsk for Johnson.
",
instance.render
end
def test_sassy_single_line_sections
instance = Mustache.new
instance[:full_time] = true
instance.template = "\n {{#full_time}}full time{{/full_time}}\n"
assert_equal "\n full time\n", instance.render
end
def test_sassier_single_line_sections
instance = Mustache.new
instance.template = "\t{{#list}}\r\n\t{{/list}}"
assert_equal "", instance.render
end
def test_padding_before_section
instance = Mustache.new
instance.template = "\t{{#list}}a{{/list}}"
assert_equal "\taa", instance.render(:list => [1, 2])
end
def test_padding_before_section_on_eos
instance = Mustache.new
instance.template = "{{#list}}\n\t{{/list}}"
assert_equal "", instance.render(:list => [1, 2])
end
def test_two_line_sections
html = %()
instance = Mustache.new
instance.template = html
instance[:no_flash] = true
assert_equal %Q'
', instance.render
end
def test_multi_line_sections_preserve_trailing_newline
view = Mustache.new
view.template = <)
instance = Mustache.new
instance.template = html
assert_equal %Q'', instance.render
end
def test_simple
assert_equal <<-end_simple, Simple.render
Hello Chris
You have just won $10000!
Well, $6000.0, after taxes.
end_simple
end
def test_hash_assignment
view = Simple.new
view[:name] = 'Bob'
view[:value] = '4000'
view[:in_ca] = false
assert_equal <<-end_simple, view.render
Hello Bob
You have just won $4000!
end_simple
end
def test_crazier_hash_assignment
view = Simple.new
view[:name] = 'Crazy'
view[:in_ca] = [
{ :taxed_value => 1 },
{ :taxed_value => 2 },
{ :taxed_value => 3 },
]
assert_equal <<-end_simple, view.render
Hello Crazy
You have just won $10000!
Well, $1, after taxes.
Well, $2, after taxes.
Well, $3, after taxes.
end_simple
end
def test_fileless_templates
view = Simple.new
view.template = 'Hi {{person}}!'
view[:person] = 'mom'
assert_equal 'Hi mom!', view.render
end
def test_delimiters
assert_equal <<-end_template, Delimiters.render
* It worked the first time.
* And it worked the second time.
* As well as the third.
* Then, surprisingly, it worked the final time.
end_template
end
def test_double_section
assert_equal <<-end_section, DoubleSection.render
* first
* second
* third
end_section
end
def test_inverted_section
assert_equal <<-end_section, InvertedSection.render
* first
* second
* third
end_section
end
def test_comments
assert_equal "
A Comedy of Errors
\n", Comments.render
end
def test_multi_linecomments
view = Comments.new
view.template = "{{title}}{{! just something interesting... \n#or not... }}
\n"
assert_equal "A Comedy of Errors
\n", view.render
end
def test_escaped
assert_equal 'Bear > Shark
', Escaped.render
end
def test_unescaped
assert_equal 'Bear > Shark
', Unescaped.render
end
def test_unescaped_ampersand
view = Mustache.new
view.template = "{{& title}}
"
view[:title] = "Bear > Shark"
assert_equal 'Bear > Shark
', view.render
end
def test_classify
assert_equal 'TemplatePartial', Mustache.classify('template_partial')
assert_equal 'Admin::TemplatePartial', Mustache.classify('admin/template_partial')
end
def test_underscore
assert_equal 'template_partial', Mustache.underscore('TemplatePartial')
assert_equal 'admin/template_partial', Mustache.underscore('Admin::TemplatePartial')
assert_equal 'views/in/sub/directories', Mustache.underscore('Views::In::Sub::Directories')
end
def test_anon_subclass_underscore
klass = Class.new(TemplatePartial)
assert_equal 'template_partial', klass.underscore
end
def test_namespaced_underscore
Object.const_set(:Views, Class.new)
klass = Class.new(Mustache)
klass.view_namespace = Views
assert_equal 'stat_stuff', klass.underscore('Views::StatStuff')
assert_equal 'views/stat_stuff', Mustache.underscore('Views::StatStuff')
end
def test_render
assert_equal 'Hello World!', Mustache.render('Hello World!')
end
def test_render_with_params
assert_equal 'Hello World!', Mustache.render('Hello {{planet}}!', :planet => 'World')
end
def test_render_from_file
expected = <<-data
ServerName example.com
DocumentRoot /var/www/example.com
RailsEnv production
data
template = File.read(File.dirname(__FILE__) + "/fixtures/passenger.conf")
assert_equal expected, Mustache.render(template, :stage => 'production',
:server => 'example.com',
:deploy_to => '/var/www/example.com' )
end
def test_render_from_symbol
expected = <<-data
ServerName example.com
DocumentRoot /var/www/example.com
RailsEnv production
data
old_path, Mustache.template_path = Mustache.template_path, File.dirname(__FILE__) + "/fixtures"
old_extension, Mustache.template_extension = Mustache.template_extension, "conf"
assert_equal expected, Mustache.render(:passenger, :stage => 'production',
:server => 'example.com',
:deploy_to => '/var/www/example.com' )
Mustache.template_path, Mustache.template_extension = old_path, old_extension
end
def test_doesnt_execute_what_it_doesnt_need_to
instance = Mustache.new
instance[:show] = false
instance.instance_eval do
def die
raise "bummer"
end
end
instance.template = '{{#show}} {{die}} {{/show}} yay'
assert_equal " yay", instance.render
end
def test_reports_unclosed_sections
instance = Mustache.new
instance[:list] = [ :item => 1234 ]
instance.template = '{{#list}} {{item}} {{/gist}}'
begin
instance.render
rescue => e
end
assert e.message.include?('Unclosed section')
end
def test_unclosed_sections_reports_the_line_number
instance = Mustache.new
instance[:list] = [ :item => 1234 ]
instance.template = "hi\nmom\n{{#list}} {{item}} {{/gist}}"
begin
instance.render
rescue => e
end
assert e.message.include?('Line 3')
end
def test_enumerable_sections_accept_a_hash_as_a_context
instance = Mustache.new
instance[:list] = { :item => 1234 }
instance.template = '{{#list}} {{item}} {{/list}}'
assert_equal ' 1234 ', instance.render
end
def test_enumerable_sections_accept_a_string_keyed_hash_as_a_context
instance = Mustache.new
instance[:list] = { 'item' => 1234 }
instance.template = '{{#list}} {{item}} {{/list}}'
assert_equal ' 1234 ', instance.render
end
def test_not_found_in_context_renders_empty_string
instance = Mustache.new
instance.template = '{{#list}} {{item}} {{/list}}'
assert_equal '', instance.render
end
def test_not_found_in_nested_context_renders_empty_string
instance = Mustache.new
instance[:list] = { :item => 1234 }
instance.template = '{{#list}} {{prefix}}{{item}} {{/list}}'
assert_equal ' 1234 ', instance.render
end
def test_not_found_in_context_raises_when_asked_to
instance = Mustache.new
instance.raise_on_context_miss = true
instance.template = '{{#list}} {{item}} {{/list}}'
assert_raises Mustache::ContextMiss do
instance.render
end
end
def test_knows_when_its_been_compiled_when_set_with_string
klass = Class.new(Mustache)
assert ! klass.compiled?
klass.template = 'Hi, {{person}}!'
assert klass.compiled?
end
def test_knows_when_its_been_compiled_when_using_a_file_template
klass = Class.new(Simple)
klass.template_file = File.dirname(__FILE__) + '/fixtures/simple.mustache'
assert ! klass.compiled?
klass.render
assert klass.compiled?
end
def test_an_instance_knows_when_its_class_is_compiled
instance = Simple.new
assert ! Simple.compiled?
assert ! instance.compiled?
Simple.render
assert Simple.compiled?
assert instance.compiled?
end
def test_knows_when_its_been_compiled_at_the_instance_level
klass = Class.new(Mustache)
instance = klass.new
assert ! instance.compiled?
instance.template = 'Hi, {{person}}!'
assert instance.compiled?
end
def test_sections_returning_lambdas_get_called_with_text
view = Lambda.new
view[:name] = 'Chris'
assert_equal "Hi Chris.\n\nHi {{name}}.", view.render.chomp
assert_equal 1, view.calls
assert_equal "Hi Chris.\n\nHi {{name}}.", view.render.chomp
assert_equal 1, view.calls
assert_equal "Hi Chris.\n\nHi {{name}}.", view.render.chomp
assert_equal 1, view.calls
end
def test_sections_which_refer_to_unary_method_call_them_as_proc
kls = Class.new(Mustache) do
def unary_method(arg)
"(#{arg})"
end
end
str = kls.render("{{#unary_method}}test{{/unary_method}}")
assert_equal "(test)", str
end
def test_lots_of_staches
template = "{{{{foo}}}}"
begin
Mustache.render(template, :foo => "defunkt")
rescue => e
end
assert e.message.include?("Illegal content in tag")
end
def test_liberal_tag_names
template = "{{first-name}} {{middle_name!}} {{lastName?}}"
hash = {
'first-name' => 'chris',
'middle_name!' => 'j',
'lastName?' => 'strath'
}
assert_equal "chris j strath", Mustache.render(template, hash)
end
def test_nested_sections_same_names
template = < [
{ "items" => [ {"a" => 1}, {"a" => 2}, {"a" => 3} ] },
{ "items" => [ {"a" => 4}, {"a" => 5}, {"a" => 6} ] },
{ "items" => [ {"a" => 7}, {"a" => 8}, {"a" => 9} ] }
]
}
assert_equal <{{id}}\n{{# has_a? }}{{id}}{{/ has_a? }}
\n{{# has_b? }}{{id}}{{/ has_b? }}
\n)
instance = Mustache.new
instance.template = html
instance[:id] = 3
instance[:has_a?] = true
instance[:has_b?] = true
assert_equal <<-rendered, instance.render
3
3
3
rendered
end
def test_utf8
klass = Class.new(Mustache)
klass.template_name = 'utf8'
klass.template_path = 'test/fixtures'
view = klass.new
view[:test] = "中文"
assert_equal <<-rendered, view.render
中文 中文
中文又来啦
rendered
end
def test_indentation
view = Mustache.new
view[:name] = 'indent'
view[:text] = 'puts :indented!'
view.template = < "nothing")
assert_equal 'nothing', Mustache.render("{{thing}}", :thing => "nothing")
end
def test_implicit_iterator
view = Mustache.new
view.template = "{{#people}}* {{.}}\n{{/people}}"
view[:people] = %w( Chris Mark Scott )
assert_equal < File.expand_path('./foo'),
:template_extension => 'stache',
:view_namespace => TestNamespace,
:view_path => './foo'
}.each do |attr, value|
base.send("#{attr}=", value)
assert_equal value, tmpl.send(attr)
end
end
def test_array_of_arrays
template = < [
[ {"a" => 1}, {"a" => 2}, {"a" => 3} ],
[ {"a" => 4}, {"a" => 5}, {"a" => 6} ],
[ {"a" => 7}, {"a" => 8}, {"a" => 9} ]
]
}
assert_equal < 'Name'}, {:name => 'Age'}, {:name => 'Weight'}]
view.template = template
assert_equal <{{header}}
{{#items}}
{{#first}}
{{name}}
{{/first}}
{{#link}}
{{name}}
{{/link}}
{{/items}}
{{#empty}}
The list is empty.
{{/empty}}
EOF
expected = [:multi,
[:static, ""],
[:mustache, :etag, [:mustache, :fetch, ["header"]]],
[:static, "
\n"],
[:mustache,
:section,
[:mustache, :fetch, ["items"]],
[:multi,
[:mustache,
:section,
[:mustache, :fetch, ["first"]],
[:multi,
[:static, " "],
[:mustache, :etag, [:mustache, :fetch, ["name"]]],
[:static, "\n"]],
%Q' {{name}}\n',
%w[{{ }}]],
[:mustache,
:section,
[:mustache, :fetch, ["link"]],
[:multi,
[:static, " "],
[:mustache, :etag, [:mustache, :fetch, ["name"]]],
[:static, "\n"]],
%Q' {{name}}\n',
%w[{{ }}]]],
%Q'{{#first}}\n {{name}}\n{{/first}}\n{{#link}}\n {{name}}\n{{/link}}\n',
%w[{{ }}]],
[:static, "\n"],
[:mustache,
:section,
[:mustache, :fetch, ["empty"]],
[:multi, [:static, "The list is empty.
\n"]],
%Q'The list is empty.
\n',
%w[{{ }}]]]
assert_equal expected, tokens
end
def test_raw_content_and_whitespace
lexer = Mustache::Parser.new
tokens = lexer.compile("{{#list}}\t{{/list}}")
expected = [:multi,
[:mustache,
:section,
[:mustache, :fetch, ["list"]],
[:multi, [:static, "\t"]],
"\t",
%w[{{ }}]]]
assert_equal expected, tokens
end
end
mustache-0.99.4/test/fixtures/ 0000755 0001750 0001750 00000000000 11643306253 016217 5 ustar virtual virtual mustache-0.99.4/test/fixtures/simple.mustache 0000644 0001750 0001750 00000000151 11643306253 021240 0 ustar virtual virtual Hello {{name}}
You have just won ${{value}}!
{{#in_ca}}
Well, ${{ taxed_value }}, after taxes.
{{/in_ca}} mustache-0.99.4/test/fixtures/simple.rb 0000644 0001750 0001750 00000000503 11643306253 020033 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Simple < Mustache
self.path = File.dirname(__FILE__)
def name
"Chris"
end
def value
10_000
end
def taxed_value
value - (value * 0.4)
end
def in_ca
true
end
end
if $0 == __FILE__
puts Simple.to_html
end
mustache-0.99.4/test/fixtures/dot_notation.rb 0000644 0001750 0001750 00000000672 11643306253 021252 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class DotNotation < Mustache
self.path = File.dirname(__FILE__)
def person
return {
:name => OpenStruct.new(:first => 'Chris', :last => 'Firescythe'),
:age => 24,
:hometown => {
:city => "Cincinnati",
:state => "OH"
}
}
end
def normal
"Normal"
end
end
if $0 == __FILE__
puts DotNotation.to_html
end
mustache-0.99.4/test/fixtures/template_partial.txt 0000644 0001750 0001750 00000000055 11643306253 022307 0 ustar virtual virtual {{title}}
{{title_bars}}
{{>inner_partial}}
mustache-0.99.4/test/fixtures/dot_notation.mustache 0000644 0001750 0001750 00000000716 11643306253 022457 0 ustar virtual virtual * {{person.name.first}} {{person.name.last}}
* {{person.age}}
* {{person.hometown.city}}, {{person.hometown.state}}
* {{#person}}{{hometown.city}}, {{hometown.state}}{{/person}}
* {{#person}}{{#hometown}}{{city}}, {{state}}{{/hometown}}{{/person}}
* {{#person.hometown}}{{city}}, {{state}}{{/person.hometown}}
* {{normal}}
* {{{person.name.first}}} {{&person.name.last}}
* {{^person.alien?}}{{person.hometown.city}}, {{person.hometown.state}}{{/person.alien?}}
mustache-0.99.4/test/fixtures/node.mustache 0000644 0001750 0001750 00000000134 11643306253 020675 0 ustar virtual virtual
{{contents}}
{{#children}}
{{> node}}
{{/children}}
mustache-0.99.4/test/fixtures/inverted_section.mustache 0000644 0001750 0001750 00000000071 11643306253 023314 0 ustar virtual virtual {{^t}}
* first
{{/t}}
* {{two}}
{{^t}}
* third
{{/t}} mustache-0.99.4/test/fixtures/crazy_recursive.mustache 0000644 0001750 0001750 00000000157 11643306253 023174 0 ustar virtual virtual
{{#top_nodes}}
{{> node}}
{{/top_nodes}}
mustache-0.99.4/test/fixtures/partial_with_module.mustache 0000644 0001750 0001750 00000000070 11643306253 024003 0 ustar virtual virtual {{greeting}}
{{>simple}}
{{farewell}}
mustache-0.99.4/test/fixtures/utf8_partial.mustache 0000644 0001750 0001750 00000000031 11643306253 022346 0 ustar virtual virtual 中文又来啦
mustache-0.99.4/test/fixtures/inner_partial.txt 0000644 0001750 0001750 00000000030 11643306253 021600 0 ustar virtual virtual ## Again, {{title}}! ##
mustache-0.99.4/test/fixtures/nested_objects.rb 0000644 0001750 0001750 00000001210 11643306253 021531 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
require 'ostruct'
class NestedObjects < Mustache
self.path = File.dirname(__FILE__)
def header
"Colors"
end
def item
items = []
items << OpenStruct.new(:name => 'red', :current => true, :url => '#Red')
items << OpenStruct.new(:name => 'green', :current => false, :url => '#Green')
items << OpenStruct.new(:name => 'blue', :current => false, :url => '#Blue')
items
end
def link
not self[:current]
end
def list
not item.empty?
end
def empty
item.empty?
end
end
if $0 == __FILE__
puts NestedObjects.to_html
end
mustache-0.99.4/test/fixtures/inner_partial.mustache 0000644 0001750 0001750 00000000021 11643306253 022572 0 ustar virtual virtual Again, {{title}}! mustache-0.99.4/test/fixtures/namespaced.mustache 0000644 0001750 0001750 00000000022 11643306253 022044 0 ustar virtual virtual {{title}}
mustache-0.99.4/test/fixtures/crazy_recursive.rb 0000644 0001750 0001750 00000001164 11643306253 021765 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class CrazyRecursive < Mustache
self.path = File.dirname(__FILE__)
def top_nodes
[{ :contents => "1",
:children =>
[{ :contents => "2",
:children =>
[{ :contents => "3",
:children => []
}]
},
{ :contents => "4",
:children =>
[{ :contents => "5",
:children =>
[{ :contents => "6",
:children => []
}]
}]
}]
}]
end
end
if $0 == __FILE__
puts CrazyRecursive.to_html
end
mustache-0.99.4/test/fixtures/inverted_section.rb 0000644 0001750 0001750 00000000313 11643306253 022105 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class InvertedSection < Mustache
self.path = File.dirname(__FILE__)
def t
false
end
def two
"second"
end
end
mustache-0.99.4/test/fixtures/partial_with_module.rb 0000644 0001750 0001750 00000000730 11643306253 022600 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
module SimpleView
def name
"Bob"
end
def value
100_000
end
def taxed_value
value - (value * 0.4)
end
def in_ca
false
end
end
class PartialWithModule < Mustache
include SimpleView
self.path = File.dirname(__FILE__)
def greeting
"Welcome"
end
def farewell
"Fair enough, right?"
end
end
if $0 == __FILE__
puts PartialWithModule.to_html
end
mustache-0.99.4/test/fixtures/delimiters.rb 0000644 0001750 0001750 00000000660 11643306253 020707 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Delimiters < Mustache
self.path = File.dirname(__FILE__)
def start
"It worked the first time."
end
def middle
[ { :item => "And it worked the second time." },
{ :item => "As well as the third." } ]
end
def final
"Then, surprisingly, it worked the final time."
end
end
if $0 == __FILE__
puts Delimiters.to_html
end
mustache-0.99.4/test/fixtures/unescaped.mustache 0000644 0001750 0001750 00000000024 11643306253 021715 0 ustar virtual virtual {{{title}}}
mustache-0.99.4/test/fixtures/unescaped.rb 0000644 0001750 0001750 00000000344 11643306253 020514 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Unescaped < Mustache
self.path = File.dirname(__FILE__)
def title
"Bear > Shark"
end
end
if $0 == __FILE__
puts Unescaped.to_html
end
mustache-0.99.4/test/fixtures/double_section.rb 0000644 0001750 0001750 00000000310 11643306253 021534 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class DoubleSection < Mustache
self.path = File.dirname(__FILE__)
def t
true
end
def two
"second"
end
end
mustache-0.99.4/test/fixtures/recursive.rb 0000644 0001750 0001750 00000000332 11643306253 020551 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Recursive < Mustache
self.path = File.dirname(__FILE__)
def show
false
end
end
if $0 == __FILE__
puts Recursive.to_html
end
mustache-0.99.4/test/fixtures/template_partial.rb 0000644 0001750 0001750 00000000430 11643306253 022070 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class TemplatePartial < Mustache
self.path = File.dirname(__FILE__)
def title
"Welcome"
end
def title_bars
'-' * title.size
end
end
if $0 == __FILE__
puts TemplatePartial.to_html
end
mustache-0.99.4/test/fixtures/utf8.mustache 0000644 0001750 0001750 00000000055 11643306253 020640 0 ustar virtual virtual 中文 {{test}}
{{> utf8_partial}}
mustache-0.99.4/test/fixtures/recursive.mustache 0000644 0001750 0001750 00000000055 11643306253 021761 0 ustar virtual virtual It works!
{{#show}}
{{>recursive}}
{{/show}}
mustache-0.99.4/test/fixtures/escaped.mustache 0000644 0001750 0001750 00000000022 11643306253 021350 0 ustar virtual virtual {{title}}
mustache-0.99.4/test/fixtures/comments.rb 0000644 0001750 0001750 00000000350 11643306253 020367 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Comments < Mustache
self.path = File.dirname(__FILE__)
def title
"A Comedy of Errors"
end
end
if $0 == __FILE__
puts Comments.to_html
end
mustache-0.99.4/test/fixtures/nested_objects.mustache 0000644 0001750 0001750 00000000424 11643306253 022745 0 ustar virtual virtual {{header}}
{{#list}}
{{#item}}
{{#current}}
- {{name}}
{{/current}}
{{#link}}
- {{name}}
{{/link}}
{{/item}}
{{/list}}
{{^list}}
The list is empty.
{{/list}} mustache-0.99.4/test/fixtures/lambda.rb 0000644 0001750 0001750 00000001001 11643306253 017754 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Lambda < Mustache
self.path = File.dirname(__FILE__)
attr_reader :calls
def initialize(*args)
super
@calls = 0
@cached = nil
end
def rendered
lambda do |text|
return @cached if @cached
@calls += 1
@cached = render(text)
end
end
def not_rendered
lambda { |text| "{{= | =}}#{text}" }
end
end
if $0 == __FILE__
puts Lambda.to_html(Lambda.template, :name => "Jonny")
end
mustache-0.99.4/test/fixtures/delimiters.mustache 0000644 0001750 0001750 00000000137 11643306253 022114 0 ustar virtual virtual {{=<% %>=}}
* <% start %>
<%=| |=%>
|# middle |
* | item |
|/ middle |
|={{ }}=|
* {{ final }}
mustache-0.99.4/test/fixtures/template_partial.mustache 0000644 0001750 0001750 00000000045 11643306253 023300 0 ustar virtual virtual {{title}}
{{>inner_partial}} mustache-0.99.4/test/fixtures/complex_view.mustache 0000644 0001750 0001750 00000000424 11643306253 022453 0 ustar virtual virtual {{header}}
{{#list}}
{{#item}}
{{#current}}
- {{name}}
{{/current}}
{{#link}}
- {{name}}
{{/link}}
{{/item}}
{{/list}}
{{^list}}
The list is empty.
{{/list}} mustache-0.99.4/test/fixtures/passenger.conf 0000644 0001750 0001750 00000000151 11643306253 021052 0 ustar virtual virtual
ServerName {{server}}
DocumentRoot {{deploy_to}}
RailsEnv {{stage}}
mustache-0.99.4/test/fixtures/escaped.rb 0000644 0001750 0001750 00000000340 11643306253 020145 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Escaped < Mustache
self.path = File.dirname(__FILE__)
def title
"Bear > Shark"
end
end
if $0 == __FILE__
puts Escaped.to_html
end
mustache-0.99.4/test/fixtures/method_missing.rb 0000644 0001750 0001750 00000000561 11643306253 021557 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class MethodMissing < Mustache
self.template = '[ {{#list}}{{.}} {{/list}}]'
def method_missing(name, *args, &block)
return (0..10).to_a if name == :list
return super
end
def respond_to?(method)
method == :list
end
end
if $0 == __FILE__
puts MethodMissing.to_html
end
mustache-0.99.4/test/fixtures/lambda.mustache 0000644 0001750 0001750 00000000132 11643306253 021166 0 ustar virtual virtual {{#rendered}}
Hi {{name}}.
{{/rendered}}
{{#not_rendered}}
Hi {{name}}.
{{/not_rendered}} mustache-0.99.4/test/fixtures/passenger.rb 0000644 0001750 0001750 00000000632 11643306253 020534 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class Passenger < Mustache
self.path = File.dirname(__FILE__)
self.template_extension = 'conf'
def server
"example.com"
end
def deploy_to
"/var/www/example.com"
end
def stage
"production"
end
def timestamp
Time.now.strftime('%Y%m%d%H%M%S')
end
end
if $0 == __FILE__
puts Passenger.to_text
end
mustache-0.99.4/test/fixtures/comments.mustache 0000644 0001750 0001750 00000000102 11643306253 021570 0 ustar virtual virtual {{title}}{{! just something interesting... #or not... }}
mustache-0.99.4/test/fixtures/complex_view.rb 0000644 0001750 0001750 00000001116 11643306253 021244 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
class ComplexView < Mustache
self.path = File.dirname(__FILE__)
def header
"Colors"
end
def item
items = []
items << { :name => 'red', :current => true, :url => '#Red' }
items << { :name => 'green', :current => false, :url => '#Green' }
items << { :name => 'blue', :current => false, :url => '#Blue' }
items
end
def link
not self[:current]
end
def list
not item.empty?
end
def empty
item.empty?
end
end
if $0 == __FILE__
puts ComplexView.to_html
end
mustache-0.99.4/test/fixtures/namespaced.rb 0000644 0001750 0001750 00000000707 11643306253 020650 0 ustar virtual virtual $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
require 'mustache'
module TestViews
class Namespaced < Mustache
self.path = File.dirname(__FILE__)
def title
"Dragon < Tiger"
end
end
class NamespacedWithPartial < Mustache
self.path = File.dirname(__FILE__)
self.template = "My opinion: {{>inner_partial}}"
def title
"Victory"
end
end
end
if $0 == __FILE__
puts TestViews::Namespaced.to_html
end
mustache-0.99.4/test/fixtures/double_section.mustache 0000644 0001750 0001750 00000000071 11643306253 022746 0 ustar virtual virtual {{#t}}
* first
{{/t}}
* {{two}}
{{#t}}
* third
{{/t}} mustache-0.99.4/test/spec_test.rb 0000644 0001750 0001750 00000004045 11643306253 016667 0 ustar virtual virtual require 'mustache'
require 'tmpdir'
require 'yaml'
require 'test/unit'
# Automatically process !code types into Proc objects
YAML::add_builtin_type('code') { |_, val| eval(val['ruby']) }
# A simple base class for Mustache specs.
# Creates a partials directory, then points a (dynamic) subclass of Mustache at
# that directory before each test; the partials directory is destroyed after
# each test is run.
class MustacheSpec < Test::Unit::TestCase
def setup
@partials = File.join(File.dirname(__FILE__), 'partials')
Dir.mkdir(@partials)
@Mustache = Class.new(Mustache)
@Mustache.template_path = @partials
end
def teardown
Dir[File.join(@partials, '*')].each { |file| File.delete(file) }
Dir.rmdir(@partials)
end
# Extracts the partials from the test, and dumps them into the partials
# directory for inclusion.
def setup_partials(test)
(test['partials'] || {}).each do |name, content|
File.open(File.join(@partials, "#{name}.mustache"), 'w') do |f|
f.print(content)
end
end
end
# Asserts equality between the rendered template and the expected value,
# printing additional context data on failure.
def assert_mustache_spec(test)
actual = @Mustache.render(test['template'], test['data'])
assert_equal test['expected'], actual, "" <<
"#{ test['desc'] }\n" <<
"Data: #{ test['data'].inspect }\n" <<
"Template: #{ test['template'].inspect }\n" <<
"Partials: #{ (test['partials'] || {}).inspect }\n"
end
def test_noop; assert(true); end
end
spec_files = File.join(File.dirname(__FILE__), '..', 'ext', 'spec', 'specs', '*.yml')
Dir[spec_files].each do |file|
spec = YAML.load_file(file)
klass_name = "Test" + File.basename(file, ".yml").sub(/~/, '').capitalize
instance_eval "class ::#{klass_name} < MustacheSpec; end"
test_suite = Kernel.const_get(klass_name)
test_suite.class_eval do
spec['tests'].each do |test|
define_method :"test - #{test['name']}" do
setup_partials(test)
assert_mustache_spec(test)
end
end
end
end
mustache-0.99.4/Rakefile 0000644 0001750 0001750 00000002700 11643306253 015033 0 ustar virtual virtual require 'rake/testtask'
require 'rake/rdoctask'
#
# Helpers
#
def command?(command)
system("type #{command} &> /dev/null")
end
#
# Tests
#
task :default => :test
if command? :turn
desc "Run tests"
task :test do
suffix = "-n #{ENV['TEST']}" if ENV['TEST']
sh "turn test/*.rb #{suffix}"
end
else
Rake::TestTask.new do |t|
t.libs << 'lib'
t.pattern = 'test/**/*_test.rb'
t.verbose = false
end
end
#
# Ron
#
if command? :ronn
desc "Show the manual"
task :man => "man:build" do
exec "man man/mustache.1"
end
desc "Build the manual"
task "man:build" do
sh "ronn -br5 --organization=DEFUNKT --manual='Mustache Manual' man/*.ron"
end
end
#
# Gems
#
desc "Push a new version to Gemcutter and publish docs."
task :publish do
require File.dirname(__FILE__) + '/lib/mustache/version'
system "git tag v#{Mustache::Version}"
sh "gem build mustache.gemspec"
sh "gem push mustache-#{Mustache::Version}.gem"
sh "git push origin master --tags"
sh "git clean -fd"
exec "rake pages"
end
#
# Documentation
#
desc "Publish to GitHub Pages"
task :pages => [ "man:build" ] do
Dir['man/*.html'].each do |f|
cp f, File.basename(f).sub('.html', '.newhtml')
end
`git commit -am 'generated manual'`
`git checkout site`
Dir['*.newhtml'].each do |f|
mv f, f.sub('.newhtml', '.html')
end
`git add .`
`git commit -m updated`
`git push site site:master`
`git checkout master`
puts :done
end
{{ login }}
{{/ users}}