mustache 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+doc

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Chris Wanstrath
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,307 @@
+Mustache
+=========
+
+Inspired by [ctemplate](http://code.google.com/p/google-ctemplate/)
+and
+[et](http://www.ivan.fomichev.name/2008/05/erlang-template-engine-prototype.html),
+Mustache is a framework-agnostic way to render logic-free views.
+
+As ctemplates says, "It emphasizes separating logic from presentation:
+it is impossible to embed application logic in this template language."
+
+
+Overview
+--------
+
+Think of Mustache as a replacement for your views. Instead of views
+consisting of ERB or HAML with random helpers and arbitrary logic,
+your views are broken into two parts: a Ruby class and an HTML
+template.
+
+We call the Ruby class the "view" and the HTML template the
+"template."
+
+All your logic, decisions, and code is contained in your view. All
+your markup is contained in your template. The template does nothing
+but reference methods in your view. 
+
+This strict separation makes it easier to write clean templates,
+easier to test your views, and more fun to work on your app's front end.
+
+
+Why?
+----
+
+I like writing Ruby. I like writing HTML. I like writing JavaScript.
+
+I don't like writing ERB, Haml, Liquid, Django Templates, putting Ruby
+in my HTML, or putting JavaScript in my HTML.
+
+
+Usage
+-----
+
+We've got an `examples` folder but here's the canonical one:
+
+    class Simple < Mustache
+      def name
+        "Chris"
+      end
+
+      def value
+        10_000
+      end
+
+      def taxed_value
+        value - (value * 0.4)
+      end
+
+      def in_ca
+        true
+      end
+    end
+
+We simply create a normal Ruby class and define methods. Some methods
+reference others, some return values, some return only booleans.
+
+Now let's write the template:
+
+    Hello {{name}}
+    You have just won ${{value}}!
+    {{#in_ca}}
+    Well, ${{taxed_value}}, after taxes.
+    {{/in_ca}}
+
+This template references our view methods. To bring it all together,
+here's the code to render actual HTML;
+
+    Simple.new.to_html
+
+Which returns the following:
+
+    Hello Chris
+    You have just won $10000!
+    Well, $6000.0, after taxes.
+
+Simple.
+
+
+Tag Types
+---------
+
+Tags are indicated by the double mustaches. `{{name}}` is a tag. Let's
+talk about the different types of tags.
+
+### Variables
+
+The most basic tag is the variable. A `{{name}}` tag in a basic
+template will try to call the `name` method on your view. If there is
+no `name` method, an exception will be raised.
+
+All variables are HTML escaped by default. If you want, for some
+reason, to return unescaped HTML you can use the triple mustache:
+`{{{name}}}`. 
+
+### Boolean Sections
+
+A section begins with a pound and ends with a slash. That is,
+`{{#person}}` begins a "person" section while `{{/person}}` ends it.
+
+If the `person` method exists and calling it returns false, the HTML
+between the pound and slash will not be displayed.
+
+If the `person` method exists and calling it returns true, the HTML
+between the pound and slash will be rendered and displayed.
+
+### Enumerable Sections
+
+Enumerable sections are syntactically identical to boolean sections in
+that they begin with a pound and end with a slash. The difference,
+however, is in the view: if the method called returns an enumerable,
+the section is repeated as the enumerable is iterated over. 
+
+Each item in the enumerable is expected to be a hash which will then
+become the context of the corresponding iteration. In this way we can
+construct loops.
+
+For example, imagine this template:
+
+    {{#repo}}
+      <b>{{name}}</b>
+    {{/repo}}
+
+And this view code:
+
+    def repo
+      Repository.all.map { |r| { :name => r.to_s } }
+    end
+
+When rendered, our view will contain a list of all repository names in
+the database.
+
+### Comments
+
+Comments begin with a bang and are ignored. The following template:
+
+    <h1>Today{{! ignore me }}.</h1>
+    
+Will render as follows:
+
+    <h1>Today.</h1>
+
+### Partials
+
+Partials begin with a less than sign, like `{{< box}}`.
+
+If a partial's view is loaded, we use that to render the HTML. If
+nothing is loaded we render the template directly using our current context.
+
+In this way partials can reference variables or sections the calling
+view defines.
+
+
+Dict-Style Views
+----------------
+
+ctemplate and friends want you to hand a dictionary to the template
+processor. Naturally Mustache supports a similar concept. Feel free
+to mix the class-based and this more procedural style at your leisure.
+
+Given this template (dict.html):
+
+    Hello {{name}}
+    You have just won ${{value}}!
+
+We can fill in the values at will:
+    
+    dict = Dict.new
+    dict[:name] = 'George'
+    dict[:value] = 100
+    dict.to_html
+
+Which returns:
+    
+    Hello George
+    You have just won $100!
+
+We can re-use the same object, too:
+
+    dict[:name] = 'Tony'
+    dict.to_html
+    Hello Tony
+    You have just won $100!
+
+
+Templates
+---------
+
+A word on templates. By default, a view will try to find its template
+on disk by searching for an HTML file in the current directory that
+follows the classic Ruby naming convention.
+
+    TemplatePartial => ./template_partial.html
+    
+You can set the search path using `Mustache.path`. It can be set on a
+class by class basis:
+
+    class Simple < Mustache
+      self.path = File.dirname(__FILE__)
+      ... etc ...
+    end
+
+Now `Simple` will look for `simple.html` in the directory it resides
+in, no matter the cwd.
+
+If you want to just change what template is used you can set
+`Mustache.template_file` directly:
+
+    Simple.template_file = './blah.html'
+    
+You can also go ahead and set the template directly:
+
+    Simple.template = 'Hi {{person}}!'
+
+You can also set a different template for only a single instance:
+
+    Simple.new.template = 'Hi {{person}}!'
+
+Whatever works.
+
+
+Helpers
+-------
+
+What about global helpers? Maybe you have a nifty `gravatar` function
+you want to use in all your views? No problem. 
+
+This is just Ruby, after all.
+
+    module ViewHelpers
+      def gravatar(email, size = 30)
+        gravatar_id = Digest::MD5.hexdigest(email.to_s.strip.downcase)
+        gravatar_for_id(gravatar_id, size)
+      end
+
+      def gravatar_for_id(gid, size = 30)
+        "#{gravatar_host}/avatar/#{gid}?s=#{size}"
+      end
+
+      def gravatar_host
+        @ssl ? 'https://secure.gravatar.com' : 'http://www.gravatar.com'
+      end
+    end
+
+Then just include it:    
+
+    class Simple < Mustache
+      include ViewHelpers
+
+      def name
+        "Chris"
+      end
+
+      def value
+        10_000
+      end
+
+      def taxed_value
+        value - (value * 0.4)
+      end
+
+      def in_ca
+        true
+      end
+    end
+
+Great, but what about that `@ssl` ivar in `gravatar_host`? There are
+many ways we can go about setting it.
+
+Here's on example which illustrates a key feature of Mustache: you
+are free to use the `initialize` method just as you would in any
+normal class.
+
+    class Simple < Mustache
+      include ViewHelpers
+
+      def initialize(ssl = false)
+        @ssl = ssl
+      end
+
+      ... etc ...
+    end
+
+Now:
+
+    Simple.new(request.ssl?).to_html
+
+Convoluted but you get the idea.
+
+
+Meta
+----
+
+* Code: `git clone git://github.com/defunkt/mustache.git`
+* Bugs: <http://github.com/defunkt/mustache/issues>
+* List: <http://groups.google.com/group/mustache-rb>
+* Test: <http://runcoderun.com/defunkt/mustache>
+* Boss: Chris Wanstrath :: <http://github.com/defunkt>

data/Rakefile

@@ -0,0 +1,36 @@
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+begin
+  require 'jeweler'
+  $LOAD_PATH.unshift 'lib'
+  require 'mustache/version'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "mustache"
+    gemspec.summary = "Mustache is a framework-agnostic way to render logic-free views."
+    gemspec.description = "Mustache is a framework-agnostic way to render logic-free views."
+    gemspec.email = "chris@ozmm.org"
+    gemspec.homepage = "http://github.com/defunkt/mustache"
+    gemspec.authors = ["Chris Wanstrath"]
+    gemspec.version = Mustache::Version
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+desc "Build sdoc documentation"
+task :doc do
+  File.open('README.html', 'w') do |f|
+    require 'rdiscount'
+    f.puts Markdown.new(File.read('README.md')).to_html
+  end
+
+  exec "sdoc -N --main=README.html README.html LICENSE lib"
+end

data/benchmarks/complex.erb

@@ -0,0 +1,15 @@
+<h1><%= header %></h1>
+<% if not item.empty? %>
+  <ul>
+  <% for i in item %>
+    <% if i[:current] %>
+      <li><strong><%= i[:name] %></strong></li>
+    <% else %>
+      <li><a href="<%= i[:url] %>"><%= i[:name] %></a></li>
+    <% end %>
+  <% end %>
+  </ul>
+<% end %>
+<% if item.empty? %>
+  <p>The list is empty.</p>
+<% end %>

data/benchmarks/helper.rb

@@ -0,0 +1,20 @@
+require 'benchmark'
+
+count = (ENV['COUNT'] || 5000).to_i
+
+$benches = []
+def bench(name, &block)
+  $benches.push([name, block])
+end
+
+at_exit do
+  Benchmark.bmbm do |x|
+    $benches.each do |name, block|
+      x.report name.to_s do
+        count.times do
+          block.call
+        end
+      end
+    end
+  end
+end

data/benchmarks/simple.erb

@@ -0,0 +1,5 @@
+Hello <%= name %>
+You have just won $<%= value %>!
+<% if in_ca %>
+Well, $<%= taxed_value %>, after taxes.
+<% end %>

data/benchmarks/speed.rb

@@ -0,0 +1,46 @@
+require 'erb'
+
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'helper'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../examples'
+require 'complex_view'
+
+## erb
+template = File.read(File.dirname(__FILE__) + '/complex.erb')
+
+unless ENV['NOERB']
+  bench 'ERB w/o caching' do
+    ERB.new(template).result(ComplexView.new.send(:binding))
+  end
+
+  erb =  ERB.new(template)
+  bench 'ERB w/ caching' do
+    erb.result(ComplexView.new.send(:binding))
+  end
+end
+
+## mustache
+tpl = ComplexView.new
+tpl.template
+
+tpl[:header] = 'Chris'
+tpl[:empty] = false
+tpl[:list] = true
+
+items = []
+items << { :name => 'red', :current => true, :url => '#Red' }
+items << { :name => 'green', :current => false, :url => '#Green' }
+items << { :name => 'blue', :current => false, :url => '#Blue' }
+
+tpl[:item] = items
+
+bench '{ w/ caching' do
+  tpl.to_html
+end
+
+bench '{ w/o caching' do
+  tpl = ComplexView.new
+  tpl[:item] = items
+  tpl.to_html
+end

data/examples/comments.html

@@ -0,0 +1 @@
+<h1>{{title}}{{! just something interesting... or not... }}</h1>

data/examples/comments.rb

@@ -0,0 +1,14 @@
+$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

data/examples/complex_view.html

@@ -0,0 +1,16 @@
+<h1>{{header}}</h1>
+{{#list}}
+  <ul>
+  {{#item}}
+    {{#current}}
+      <li><strong>{{name}}</strong></li>
+    {{/current}}
+    {{#link}}
+      <li><a href="{{url}}">{{name}}</a></li>
+    {{/link}}
+  {{/item}}
+  </ul>
+{{/list}}
+{{#empty}}
+  <p>The list is empty.</p>
+{{/empty}}

data/examples/complex_view.rb

@@ -0,0 +1,34 @@
+$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 context[:current]
+  end
+
+  def list
+    not item.empty?
+  end
+
+  def empty
+    item.empty?
+  end
+end
+
+if $0 == __FILE__
+  puts ComplexView.to_html
+end

data/examples/escaped.html

@@ -0,0 +1 @@
+<h1>{{title}}</h1>

data/examples/escaped.rb

@@ -0,0 +1,14 @@
+$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

data/examples/inner_partial.html

@@ -0,0 +1 @@
+Again, {{title}}!

data/examples/simple.html

@@ -0,0 +1,5 @@
+Hello {{name}}
+You have just won ${{value}}!
+{{#in_ca}}
+Well, ${{ taxed_value }}, after taxes.
+{{/in_ca}}

data/examples/simple.rb

@@ -0,0 +1,26 @@
+$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

data/examples/template_partial.html

@@ -0,0 +1,2 @@
+<h1>{{title}}</h1>
+{{<inner_partial}}

data/examples/template_partial.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'mustache'
+
+class TemplatePartial < Mustache
+  self.path = File.dirname(__FILE__)
+
+  def title
+    "Welcome"
+  end
+end
+
+if $0 == __FILE__
+  puts TemplatePartial.to_html
+end

data/examples/unescaped.html

@@ -0,0 +1 @@
+<h1>{{{title}}}</h1>

data/examples/unescaped.rb

@@ -0,0 +1,14 @@
+$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

data/examples/view_partial.html

@@ -0,0 +1,3 @@
+<h1>{{greeting}}</h1>
+{{<simple}}
+<h3>{{farewell}}</h3>

data/examples/view_partial.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require 'mustache'
+
+class ViewPartial < Mustache
+  self.path = File.dirname(__FILE__)
+
+  def greeting
+    "Welcome"
+  end
+
+  def farewell
+    "Fair enough, right?"
+  end
+end
+
+if $0 == __FILE__
+  puts ViewPartial.to_html
+end

data/lib/mustache.rb

@@ -0,0 +1,218 @@
+require 'cgi'
+
+class Mustache
+  # A Template is a compiled version of a Mustache template.
+  class Template
+    def initialize(source, template_path)
+      @source = source
+      @template_path = template_path
+      @tmpid = 0
+    end
+
+    def render(context)
+      class << self; self; end.class_eval <<-EOF, __FILE__, __LINE__ - 1
+        def render(ctx)
+          #{compile}
+        end
+      EOF
+      render(context)
+    end
+
+    def compile(src = @source)
+      "\"#{compile_sections(src)}\""
+    end
+
+  private
+    # {{#sections}}okay{{/sections}}
+    #
+    # Sections can return true, false, or an enumerable.
+    # If true, the section is displayed.
+    # If false, the section is not displayed.
+    # If enumerable, the return value is iterated over (a for loop).
+    def compile_sections(src)
+      res = ""
+      while src =~ /^\s*\{\{\#(.+)\}\}\n*(.+)^\s*\{\{\/\1\}\}\n*/m
+        res << compile_tags($`)
+        name = $1.strip.to_sym.inspect
+        code = compile($2)
+        ctxtmp = "ctx#{tmpid}"
+        res << ev("(v = ctx[#{name}]) ? v.respond_to?(:each) ? "\
+          "(#{ctxtmp}=ctx.dup; r=v.map{|h|ctx.merge!(h);#{code}}.join; "\
+          "ctx.replace(#{ctxtmp});r) : #{code} : ''")
+        src = $'
+      end
+      res << compile_tags(src)
+    end
+
+    # Find and replace all non-section tags.
+    # In particular we look for four types of tags:
+    # 1. Escaped variable tags - {{var}}
+    # 2. Unescaped variable tags - {{{var}}}
+    # 3. Comment variable tags - {{! comment}
+    # 4. Partial tags - {{< partial_name }}
+    def compile_tags(src)
+      res = ""
+      while src =~ /\{\{(!|<|\{)?([^\/#]+?)\1?\}\}+/
+        res << str($`)
+        case $1
+        when '!'
+          # ignore comments
+        when '<'
+          res << compile_partial($2.strip)
+        when '{'
+          res << utag($2.strip)
+        else
+          res << etag($2.strip)
+        end
+        src = $'
+      end
+      res << str(src)
+    end
+
+    # Partials are basically a way to render views from inside other views.
+    def compile_partial(name)
+      klass = Mustache.classify(name)
+      if Object.const_defined?(klass)
+        ev("#{klass}.to_html")
+      else
+        src = File.read(@template_path + '/' + name + '.html')
+        compile(src)[1..-2]
+      end
+    end
+
+    # Generate a temporary id.
+    def tmpid
+      @tmpid += 1
+    end
+
+    def str(s)
+      s.inspect[1..-2]
+    end
+
+    def etag(s)
+      ev("Mustache.escape(ctx[#{s.strip.to_sym.inspect}])")
+    end
+
+    def utag(s)
+      ev("ctx[#{s.strip.to_sym.inspect}]")
+    end
+
+    def ev(s)
+      "#\{#{s}}"
+    end
+  end
+
+  class Context < Hash
+    def initialize(mustache)
+      @mustache = mustache
+      super()
+    end
+
+    def [](name)
+      if has_key?(name)
+        super
+      elsif @mustache.respond_to?(name)
+        @mustache.send(name)
+      else
+        raise "Can't find #{name} in #{inspect}"
+      end
+    end
+  end
+
+  # Helper method for quickly instantiating and rendering a view.
+  def self.to_html
+    new.to_html
+  end
+
+  # The path informs your Mustache subclass where to look for its
+  # corresponding template.
+  def self.path=(path)
+    @path = File.expand_path(path)
+  end
+
+  def self.path
+    @path || '.'
+  end
+
+  # Templates are self.class.name.underscore + '.html' -- a class of
+  # Dashboard would have a template (relative to the path) of
+  # dashboard.html
+  def self.template_file
+    @template_file ||= path + '/' + underscore(to_s) + '.html'
+  end
+
+  def self.template_file=(template_file)
+    @template_file = template_file
+  end
+
+  def self.template
+    @template ||= templateify(File.read(template_file))
+  end
+
+  # template_partial => TemplatePartial
+  def self.classify(underscored)
+    underscored.split(/[-_]/).map { |part| part[0] = part[0].chr.upcase; part }.join
+  end
+
+  # TemplatePartial => template_partial
+  def self.underscore(classified)
+    string = classified.dup.split('::').last
+    string[0] = string[0].chr.downcase
+    string.gsub(/[A-Z]/) { |s| "_#{s.downcase}"}
+  end
+
+  # Escape HTML.
+  def self.escape(string)
+    CGI.escapeHTML(string.to_s)
+  end
+
+  def self.templateify(obj)
+    obj.is_a?(Template) ? obj : Template.new(obj.to_s, path)
+  end
+
+  # The template itself. You can override this if you'd like.
+  def template
+    @template ||= self.class.template
+  end
+
+  def template=(template)
+    @template = self.class.templateify(template)
+  end
+
+  # Pass a block to `debug` with your debug putses. Set the `DEBUG`
+  # env variable when you want to run those blocks.
+  #
+  # e.g.
+  #  debug { puts @context.inspect }
+  def debug
+    yield if ENV['DEBUG']
+  end
+
+  # A helper method which gives access to the context at a given time.
+  # Kind of a hack for now, but useful when you're in an iterating section
+  # and want access to the hash currently being iterated over.
+  def context
+    @context ||= Context.new(self)
+  end
+
+  # Context accessors
+  def [](key)
+    context[key.to_sym]
+  end
+
+  def []=(key, value)
+    context[key.to_sym] = value
+  end
+
+  # How we turn a view object into HTML. The main method, if you will.
+  def to_html
+    render template
+  end
+
+  # Parses our fancy pants template HTML and returns normal HTML with
+  # all special {{tags}} and {{#sections}}replaced{{/sections}}.
+  def render(html, ctx = {})
+    html = self.class.templateify(html)
+    html.render(context.update(ctx))
+  end
+end

data/lib/mustache/sinatra.rb

@@ -0,0 +1,56 @@
+=begin
+Support for Mustache in your Sinatra app.
+
+  require 'mustache/sinatra'
+
+  class App < Sinatra::Base
+    helpers Mustache::Sinatra
+
+    get '/stats' do
+      mustache :stats
+    end
+  end
+
+If a `Views::Stats` class exists in the above example,
+Mustache will try to instantiate and use it for the rendering.
+
+If no `Views::Stats` class exists Mustache will render the template
+file directly.
+
+You can indeed use layouts with this library. Where you'd normally
+<%= yield %> you instead {{yield}} - the body of the subview is
+set to the `yield` variable and made available to you.
+=end
+require 'mustache'
+
+class Mustache
+  module Sinatra
+    # Call this in your Sinatra routes.
+    def mustache(template, options={}, locals={})
+      render :mustache, template, options, locals
+    end
+
+    # This is called by Sinatra's `render` with the proper paths
+    # and, potentially, a block containing a sub-view
+    def render_mustache(template, data, options, locals, &block)
+      name = Mustache.classify(template.to_s)
+
+      if defined?(Views) && Views.const_defined?(name)
+        instance = Views.const_get(name).new
+      else
+        instance = Mustache.new
+      end
+
+      locals.each do |local, value|
+        instance[local] = value
+      end
+
+      # If we're paseed a block it's a subview. Sticking it in yield
+      # lets us use {{yield}} in layout.html to render the actual page.
+      instance[:yield] = block.call if block
+
+      instance.template = data
+      instance.to_html
+    end
+  end
+end

data/test/mustache_test.rb

@@ -0,0 +1,111 @@
+require 'test/unit'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../examples'
+require 'simple'
+require 'complex_view'
+require 'view_partial'
+require 'template_partial'
+require 'escaped'
+require 'unescaped'
+require 'comments'
+
+class MustacheTest < Test::Unit::TestCase
+  def test_complex_view
+    assert_equal <<-end_complex, ComplexView.to_html
+<h1>Colors</h1>
+  <ul>
+      <li><strong>red</strong></li>
+      <li><a href="#Green">green</a></li>
+      <li><a href="#Blue">blue</a></li>
+  </ul>
+end_complex
+  end
+
+  def test_simple
+    assert_equal <<-end_simple, Simple.to_html
+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.to_html
+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.to_html
+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.to_html
+  end
+
+  def test_view_partial
+    assert_equal <<-end_partial.strip, ViewPartial.to_html
+<h1>Welcome</h1>
+Hello Chris
+You have just won $10000!
+Well, $6000.0, after taxes.
+
+<h3>Fair enough, right?</h3>
+end_partial
+  end
+
+  def test_template_partial
+    assert_equal <<-end_partial.strip, TemplatePartial.to_html
+<h1>Welcome</h1>
+Again, Welcome!
+end_partial
+  end
+
+  def test_comments
+    assert_equal "<h1>A Comedy of Errors</h1>\n", Comments.to_html
+  end
+
+  def test_escaped
+    assert_equal '<h1>Bear &gt; Shark</h1>', Escaped.to_html
+  end
+
+  def test_unescaped
+    assert_equal '<h1>Bear > Shark</h1>', Unescaped.to_html
+  end
+
+  def test_classify
+    assert_equal 'TemplatePartial', Mustache.classify('template_partial')
+  end
+
+  def test_underscore
+    assert_equal 'template_partial', Mustache.underscore('TemplatePartial')
+  end
+
+  def test_namespaced_underscore
+    assert_equal 'stat_stuff', Mustache.underscore('Views::StatStuff')
+  end
+end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification 
+name: mustache
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Chris Wanstrath
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-05 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Mustache is a framework-agnostic way to render logic-free views.
+email: chris@ozmm.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- benchmarks/complex.erb
+- benchmarks/helper.rb
+- benchmarks/simple.erb
+- benchmarks/speed.rb
+- examples/comments.html
+- examples/comments.rb
+- examples/complex_view.html
+- examples/complex_view.rb
+- examples/escaped.html
+- examples/escaped.rb
+- examples/inner_partial.html
+- examples/simple.html
+- examples/simple.rb
+- examples/template_partial.html
+- examples/template_partial.rb
+- examples/unescaped.html
+- examples/unescaped.rb
+- examples/view_partial.html
+- examples/view_partial.rb
+- lib/mustache.rb
+- lib/mustache/sinatra.rb
+- test/mustache_test.rb
+has_rdoc: true
+homepage: http://github.com/defunkt/mustache
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Mustache is a framework-agnostic way to render logic-free views.
+test_files: 
+- test/mustache_test.rb
+- examples/comments.rb
+- examples/complex_view.rb
+- examples/escaped.rb
+- examples/simple.rb
+- examples/template_partial.rb
+- examples/unescaped.rb
+- examples/view_partial.rb