mustache 0.7.0 → 0.9.0

data/bin/mustache

@@ -1,51 +1,90 @@
 #!/usr/bin/env ruby
 
-require 'mustache'
 require 'yaml'
+require 'optparse'
 
-def help
-  puts <<-usage
-Usage:
-  $ cat data.yml template.mustache | mustache
-  $ mustache data.yml template.mustache
-  $ cat <<data | druby mustache - template.mustache
----
-name: Bob
-age: 30
----
-data
-
-See compiled Ruby string:
-  $ mustache -c FILE
-
-Help:
-  $ mustache -h
-
-See mustache(1) or http://defunkt.github.com/mustache/mustache.1.html
-for an overview.
-usage
-end
+require 'mustache'
+require 'mustache/version'
+
+class Mustache
+  class CLI
+    # Return a structure describing the options.
+    def self.parse_options(args)
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: mustache [-c] [-t] FILE ..."
+
+        opts.separator " "
+
+        opts.separator "Examples:"
+        opts.separator "  $ mustache data.yml template.mustache"
+        opts.separator "  $ cat data.yml | mustache - template.mustache"
+        opts.separator "  $ mustache -c template.mustache"
+
+        opts.separator " "
+
+        opts.separator "  See mustache(1) or " +
+          "http://defunkt.github.com/mustache/mustache.1.html"
+        opts.separator "  for more details."
+
+        opts.separator " "
+        opts.separator "Options:"
+
+        opts.on("-c", "--compile FILE",
+          "Print the compiled Ruby for a given template.") do |file|
+          puts Mustache::Template.new(File.read(file)).compile
+          exit
+        end
 
-if (ARGV.delete('-c') || ARGV.delete('--compile')) && (file = ARGV[0])
-  puts Mustache.compile(File.read(file))
+        opts.on("-t", "--tokens FILE",
+          "Print the tokenized form of a given template.") do |file|
+          require 'pp'
+          pp Mustache::Template.new(File.read(file)).tokens
+          exit
+        end
 
-elsif ($stdin.tty? && ARGV.empty?) || ARGV.delete('-h') || ARGV.delete('--help')
-  help
+        opts.separator "Common Options:"
 
-else
-  # Not at a terminal, read from STDIN and print rendered templates to
-  # STDOUT.
-  doc = ARGF.read
+        opts.on("-v", "--version", "Print the version") do |v|
+          puts "Mustache v#{Mustache::Version}"
+          exit
+        end
 
-  if doc =~ /^(\s*---(.+)---\s*)/m
-    yaml = $2.strip
-    template = doc.sub($1, '')
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+      end
 
-    YAML.each_document(yaml) do |data|
-      puts Mustache.render(template, data)
+      opts.separator ""
+
+      opts.parse!(args)
+    end
+
+    # Does the dirty work of reading files from STDIN and the command
+    # line then processing them. The meat of this script, if you will.
+    def self.process_files(input_stream)
+      doc = input_stream.read
+
+      if doc =~ /^(\s*---(.+)---\s*)/m
+        yaml = $2.strip
+        template = doc.sub($1, '')
+
+        YAML.each_document(yaml) do |data|
+          puts Mustache.render(template, data)
+        end
+      else
+        puts doc
+      end
     end
-  else
-    puts doc
   end
-  exit
 end
+
+# Help is the default.
+ARGV << '-h' if ARGV.empty? && $stdin.tty?
+
+# Process options
+Mustache::CLI.parse_options(ARGV) if $stdin.tty?
+
+# Still here - process ARGF
+Mustache::CLI.process_files(ARGF)
+

data/lib/mustache.rb

@@ -85,14 +85,6 @@ class Mustache
     render(*args)
   end
 
-  # Compiles a string template and returns it as a string for use as
-  # an interpolated Ruby string (not fully rendered HTML), e.g.
-  # >> Mustache.compile("Hi, {{person}}!")
-  # => "Hi, #{CGI.escapeHTML(ctx[:person].to_s)}!"
-  def self.compile(template)
-    templateify(template).to_s
-  end
-
   # Given a file name and an optional context, attempts to load and
   # render the file as a template.
   def self.render_file(name, context = {})
@@ -145,7 +137,7 @@ class Mustache
   # The template file is the absolute path of the file Mustache will
   # use as its template. By default it's ./class_name.mustache
   def self.template_file
-    @template_file || "#{path}/#{underscore}.#{template_extension}"
+    @template_file || "#{path}/#{template_name}.#{template_extension}"
   end
 
   def self.template_file=(template_file)
@@ -271,7 +263,7 @@ class Mustache
     if obj.is_a?(Template)
       obj
     else
-      Template.new(obj.to_s, template_path, template_extension)
+      Template.new(obj.to_s)
     end
   end
 
@@ -318,7 +310,16 @@ class Mustache
   # Parses our fancy pants template file and returns normal file with
   # all special {{tags}} and {{#sections}}replaced{{/sections}}.
   def render(data = template, ctx = {})
-    templateify(data).render(context.update(ctx))
+    tpl = templateify(data)
+
+    return tpl.render(context) if ctx == {}
+
+    begin
+      context.push(ctx)
+      tpl.render(context)
+    ensure
+      context.pop
+    end
   end
   alias_method :to_html, :render
   alias_method :to_text, :render

data/lib/mustache/generator.rb

@@ -0,0 +1,139 @@
+class Mustache
+  # The Generator is in charge of taking an array of Mustache tokens,
+  # usually assembled by the Parser, and generating an interpolatable
+  # Ruby string. This string is considered the "compiled" template
+  # because at that point we're relying on Ruby to do the parsing and
+  # run our code.
+  #
+  # For example, let's take this template:
+  #
+  #   Hi {{thing}}!
+  #
+  # If we run this through the Parser we'll get these tokens:
+  #
+  #   [:multi,
+  #     [:static, "Hi "],
+  #     [:mustache, :etag, "thing"],
+  #     [:static, "!\n"]]
+  #
+  # Now let's hand that to the Generator:
+  #
+  # >> puts Mustache::Generator.new.compile(tokens)
+  # "Hi #{CGI.escapeHTML(ctx[:thing].to_s)}!\n"
+  #
+  # You can see the generated Ruby string for any template with the
+  # mustache(1) command line tool:
+  #
+  #   $ mustache --compile test.mustache
+  #   "Hi #{CGI.escapeHTML(ctx[:thing].to_s)}!\n"
+  class Generator
+    # Options are unused for now but may become useful in the future.
+    def initialize(options = {})
+      @options = options
+    end
+
+    # Given an array of tokens, returns an interpolatable Ruby string.
+    def compile(exp)
+      "\"#{compile!(exp)}\""
+    end
+
+    # Given an array of tokens, converts them into Ruby code. In
+    # particular there are three types of expressions we are concerned
+    # with:
+    #
+    #   :multi
+    #     Mixed bag of :static, :mustache, and whatever.
+    #
+    #   :static
+    #     Normal HTML, the stuff outside of {{mustaches}}.
+    #
+    #   :mustache
+    #     Any Mustache tag, from sections to partials.
+    #
+    # To give you an idea of what you'll be dealing with take this
+    # template:
+    #
+    #   Hello {{name}}
+    #   You have just won ${{value}}!
+    #   {{#in_ca}}
+    #   Well, ${{taxed_value}}, after taxes.
+    #   {{/in_ca}}
+    #
+    # If we run this through the Parser, we'll get back this array of
+    # tokens:
+    #
+    #   [:multi,
+    #    [:static, "Hello "],
+    #    [:mustache, :etag, "name"],
+    #    [:static, "\nYou have just won $"],
+    #    [:mustache, :etag, "value"],
+    #    [:static, "!\n"],
+    #    [:mustache,
+    #     :section,
+    #     "in_ca",
+    #     [:multi,
+    #      [:static, "Well, $"],
+    #      [:mustache, :etag, "taxed_value"],
+    #      [:static, ", after taxes.\n"]]]]
+    def compile!(exp)
+      case exp.first
+      when :multi
+        exp[1..-1].map { |e| compile!(e) }.join
+      when :static
+        str(exp[1])
+      when :mustache
+        send("on_#{exp[1]}", *exp[2..-1])
+      else
+        raise "Unhandled exp: #{exp.first}"
+      end
+    end
+
+    # Callback fired when the compiler finds a section token. We're
+    # passed the section name and the array of tokens.
+    def on_section(name, content)
+      # Convert the tokenized content of this section into a Ruby
+      # string we can use.
+      code = compile(content)
+
+      # Compile the Ruby for this section now that we know what's
+      # inside the section.
+      ev(<<-compiled)
+      if v = ctx[#{name.to_sym.inspect}]
+        if v == true
+          #{code}
+        else
+          v = [v] unless v.is_a?(Array) # shortcut when passed non-array
+          v.map { |h| ctx.push(h); r = #{code}; ctx.pop; r }.join
+        end
+      end
+      compiled
+    end
+
+    # Fired when the compiler finds a partial. We want to return code
+    # which calls a partial at runtime instead of expanding and
+    # including the partial's body to allow for recursive partials.
+    def on_partial(name)
+      ev("ctx.partial(#{name.to_sym.inspect})")
+    end
+
+    # An unescaped tag.
+    def on_utag(name)
+      ev("ctx[#{name.to_sym.inspect}]")
+    end
+
+    # An escaped tag.
+    def on_etag(name)
+      ev("CGI.escapeHTML(ctx[#{name.to_sym.inspect}].to_s)")
+    end
+
+    # An interpolation-friendly version of a string, for use within a
+    # Ruby string.
+    def ev(s)
+      "#\{#{s}}"
+    end
+
+    def str(s)
+      s.inspect[1..-2]
+    end
+  end
+end

data/lib/mustache/parser.rb

@@ -0,0 +1,216 @@
+require 'strscan'
+
+class Mustache
+  # The Parser is responsible for taking a string template and
+  # converting it into an array of tokens and, really, expressions. It
+  # raises SyntaxError if there is anything it doesn't understand and
+  # knows which sigil corresponds to which tag type.
+  #
+  # For example, given this template:
+  #
+  #   Hi {{thing}}!
+  #
+  # Run through the Parser we'll get these tokens:
+  #
+  #   [:multi,
+  #     [:static, "Hi "],
+  #     [:mustache, :etag, "thing"],
+  #     [:static, "!\n"]]
+  #
+  # You can see the array of tokens for any template with the
+  # mustache(1) command line tool:
+  #
+  #   $ mustache --tokens test.mustache
+  #   [:multi, [:static, "Hi "], [:mustache, :etag, "thing"], [:static, "!\n"]]
+  class Parser
+    # A SyntaxError is raised when the Parser comes across unclosed
+    # tags, sections, illegal content in tags, or anything of that
+    # sort.
+    class SyntaxError < StandardError
+      def initialize(message, position)
+        @message = message
+        @lineno, @column, @line = position
+        @stripped_line = @line.strip
+        @stripped_column = @column - (@line.size - @line.lstrip.size)
+      end
+
+      def to_s
+        <<-EOF
+#{@message}
+  Line #{@lineno}
+    #{@stripped_line}
+    #{' ' * @stripped_column}^
+EOF
+      end
+    end
+
+    # After these types of tags, all whitespace will be skipped.
+    SKIP_WHITESPACE = [ '#', '/' ]
+
+    # The content allowed in a tag name.
+    ALLOWED_CONTENT = /(\w|[?!-])*/
+
+    # These types of tags allow any content,
+    # the rest only allow ALLOWED_CONTENT.
+    ANY_CONTENT = [ '!', '=' ]
+
+    attr_reader :scanner, :result
+    attr_writer :otag, :ctag
+
+    # Accepts an options hash which does nothing but may be used in
+    # the future.
+    def initialize(options = {})
+      @options = {}
+    end
+
+    # The opening tag delimiter. This may be changed at runtime.
+    def otag
+      @otag ||= '{{'
+    end
+
+    # The closing tag delimiter. This too may be changed at runtime.
+    def ctag
+      @ctag ||= '}}'
+    end
+
+    # Given a string template, returns an array of tokens.
+    def compile(template)
+      # Keeps information about opened sections.
+      @sections = []
+      @result = [:multi]
+      @scanner = StringScanner.new(template)
+
+      # Scan until the end of the template.
+      until @scanner.eos?
+        scan_tags || scan_text
+      end
+
+      if !@sections.empty?
+        # We have parsed the whole file, but there's still opened sections.
+        type, pos, result = @sections.pop
+        error "Unclosed section #{type.inspect}", pos
+      end
+
+      @result
+    end
+
+    # Find {{mustaches}} and add them to the @result array.
+    def scan_tags
+      # Scan until we hit an opening delimiter.
+      return unless @scanner.scan(regexp(otag))
+
+      # Since {{= rewrites ctag, we store the ctag which should be used
+      # when parsing this specific tag.
+      current_ctag = self.ctag
+      type = @scanner.scan(/#|\/|=|!|<|>|&|\{/)
+      @scanner.skip(/\s*/)
+
+      # ANY_CONTENT tags allow any character inside of them, while
+      # other tags (such as variables) are more strict.
+      if ANY_CONTENT.include?(type)
+        r = /\s*#{regexp(type)}?#{regexp(current_ctag)}/
+        content = scan_until_exclusive(r)
+      else
+        content = @scanner.scan(ALLOWED_CONTENT)
+      end
+
+      # We found {{ but we can't figure out what's going on inside.
+      error "Illegal content in tag" if content.empty?
+
+      # Based on the sigil, do what needs to be done.
+      case type
+      when '#'
+        block = [:multi]
+        @result << [:mustache, :section, content, block]
+        @sections << [content, position, @result]
+        @result = block
+      when '/'
+        section, pos, result = @sections.pop
+        @result = result
+
+        if section.nil?
+          error "Closing unopened #{content.inspect}"
+        elsif section != content
+          error "Unclosed section #{section.inspect}", pos
+        end
+      when '!'
+        # ignore comments
+      when '='
+        self.otag, self.ctag = content.split(' ', 2)
+      when '>', '<'
+        @result << [:mustache, :partial, content]
+      when '{', '&'
+        # The closing } in unescaped tags is just a hack for
+        # aesthetics.
+        type = "}" if type == "{"
+        @result << [:mustache, :utag, content]
+      else
+        @result << [:mustache, :etag, content]
+      end
+
+      # Skip whitespace and any balancing sigils after the content
+      # inside this tag.
+      @scanner.skip(/\s+/)
+      @scanner.skip(regexp(type)) if type
+
+      # Try to find the closing tag.
+      unless close = @scanner.scan(regexp(current_ctag))
+        error "Unclosed tag"
+      end
+
+      # Skip whitespace following this tag if we need to.
+      @scanner.skip(/\s+/) if SKIP_WHITESPACE.include?(type)
+    end
+
+    # Try to find static text, e.g. raw HTML with no {{mustaches}}.
+    def scan_text
+      text = scan_until_exclusive(regexp(otag))
+
+      if text.nil?
+        # Couldn't find any otag, which means the rest is just static text.
+        text = @scanner.rest
+        # Mark as done.
+        @scanner.clear
+      end
+
+      @result << [:static, text]
+    end
+
+    # Scans the string until the pattern is matched. Returns the substring
+    # *excluding* the end of the match, advancing the scan pointer to that
+    # location. If there is no match, nil is returned.
+    def scan_until_exclusive(regexp)
+      pos = @scanner.pos
+      if @scanner.scan_until(regexp)
+        @scanner.pos -= @scanner.matched.size
+        @scanner.pre_match[pos..-1]
+      end
+    end
+
+    # Returns [lineno, column, line]
+    def position
+      # The rest of the current line
+      rest = @scanner.check_until(/\n|\Z/).to_s.chomp
+
+      # What we have parsed so far
+      parsed = @scanner.string[0...@scanner.pos]
+
+      lines = parsed.split("\n")
+
+      [ lines.size, lines.last.size - 1, lines.last + rest ]
+    end
+
+    # Used to quickly convert a string into a regular expression
+    # usable by the string scanner.
+    def regexp(thing)
+      /#{Regexp.escape(thing)}/
+    end
+
+    # Raises a SyntaxError. The message should be the name of the
+    # error - other details such as line number and position are
+    # handled for you.
+    def error(message, pos = position)
+      raise SyntaxError.new(message, pos)
+    end
+  end
+end

data/lib/mustache/sinatra.rb

@@ -9,21 +9,21 @@ class Mustache
   #   class Hurl < Sinatra::Base
   #     register Mustache::Sinatra
   #
-  #     # Should be the path to your .mustache template files.
-  #     set :views, "path/to/mustache/templates"
+  #     set :mustache, {
+  #       # Should be the path to your .mustache template files.
+  #       :templates => "path/to/mustache/templates",
   #
-  #     # Should be the path to your .rb Mustache view files.
-  #     # Only needed if different from the `views` setting
-  #     set :mustaches, "path/to/mustache/views"
+  #       # Should be the path to your .rb Mustache view files.
+  #       :views => "path/to/mustache/views",
   #
-  #     # This tells Mustache where to look for the Views module,
-  #     # under which your View classes should live. By default it's
-  #     # the class of your app - in this case `Hurl`. That is, for an :index
-  #     # view Mustache will expect Hurl::Views::Index by default.
-  #
-  #     # If our Sinatra::Base subclass was instead Hurl::App,
-  #     # we'd want to do `set :namespace, Hurl::App`
-  #     set :namespace, Hurl
+  #       # This tells Mustache where to look for the Views module,
+  #       # under which your View classes should live. By default it's
+  #       # the class of your app - in this case `Hurl`. That is, for an :index
+  #       # view Mustache will expect Hurl::Views::Index by default.
+  #       # If our Sinatra::Base subclass was instead Hurl::App,
+  #       # we'd want to do `set :namespace, Hurl::App`
+  #       :namespace => Hurl
+  #     }
   #
   #     get '/stats' do
   #       mustache :stats
@@ -43,32 +43,40 @@ class Mustache
     module Helpers
       # Call this in your Sinatra routes.
       def mustache(template, options={}, locals={})
-        render :mustache, template, options, locals
-      end
+        # Locals can be passed as options under the :locals key.
+        locals.update(options.delete(:locals) || {})
 
-      # This is called by Sinatra's `render` with the proper paths
-      # and, potentially, a block containing a sub-view
-      def render_mustache(template, data, opts, locals, &block)
-        # If you have Hurl::App::Views, namespace should be set to Hurl::App.
-        Mustache.view_namespace = options.namespace
+        # Grab any user-defined settings.
+        if settings.respond_to?(:mustache)
+          options = settings.send(:mustache).merge(options)
+        end
 
-        # This is probably the same as options.views, but we'll set it anyway.
-        # It's used to tell Mustache where to look for view classes.
-        Mustache.view_path = options.mustaches
+        # Find and cache the view class we want. This ensures the
+        # compiled template is cached, too - no looking up and
+        # compiling templates on each page load.
+        klass = mustache_class(template, options)
 
-        # Grab the class!
-        klass = Mustache.view_class(template)
+        # If they aren't explicitly diabling layouts, try to find
+        # one.
+        if options[:layout] != false
+          # If they passed a layout name use that.
+          layout = mustache_class(options[:layout] || :layout, options)
 
-        # Only cache the data if this isn't the generic base class.
-        klass.template = data unless klass == Mustache
+          # If it's just an anonymous subclass then don't bother, otherwise
+          # give us a layout instance.
+          if layout.name.empty?
+            layout = nil
+          else
+            layout = layout.new
+          end
 
-        # Confusingly Sinatra's `views` setting tells Mustache where the
-        # templates are found. It's fine, blame Chris.
-        if klass.template_path != options.views
-          klass.template_path = options.views
+          # Does the view subclass the layout? If so we'll use the
+          # view to render the layout so you can override layout
+          # methods in your view - tricky.
+          view_subclasses_layout = klass < layout.class if layout
         end
 
-        # Create a new instance for playing with
+        # Create a new instance for playing with.
         instance = klass.new
 
         # Copy instance variables set in Sinatra to the view
@@ -76,24 +84,65 @@ class Mustache
           instance.instance_variable_set(name, instance_variable_get(name))
         end
 
-        # Locals get added to the view's context
-        locals.each do |local, value|
-          instance[local] = value
+        # Render with locals.
+        rendered = instance.render(instance.template, locals)
+
+        # Now render the layout with the view we just rendered, if we
+        # need to.
+        if layout && view_subclasses_layout
+          rendered = instance.render(layout.template, :yield => rendered)
+        elsif layout
+          rendered = layout.render(layout.template, :yield => rendered)
         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
+        # That's it.
+        rendered
+      end
+
+      # Returns a View class for a given template name.
+      def mustache_class(template, options)
+        @template_cache.fetch(:mustache, template) do
+          compile_mustache(template, options)
+        end
+      end
+
+      # Given a view name and settings, finds and prepares an
+      # appropriate view class for this view.
+      def compile_mustache(view, options = {})
+        options[:templates] ||= settings.views if settings.respond_to?(:views)
+        options[:namespace] ||= self.class
+
+        factory = Class.new(Mustache) do
+          self.view_namespace = options[:namespace]
+          self.view_path      = options[:views]
+        end
+
+        # Try to find the view class for a given view, e.g.
+        # :view => Hurl::Views::Index.
+        klass = factory.view_class(view)
+
+        # If there is no view class, issue a warning and use the one
+        # we just generated to cache the compiled template.
+        if klass == Mustache
+          warn "No view class found for #{view} in #{factory.view_path}"
+          klass = factory
+
+          # If this is a generic view class make sure we set the
+          # template name as it was given. That is, an anonymous
+          # subclass of Mustache won't know how to find the
+          # "index.mustache" template unless we tell it to.
+          klass.template_name = view.to_s
+        end
 
-        instance.template = data unless instance.compiled?
-        instance.to_html
+        # Set the template path and return our class.
+        klass.template_path = options[:templates] if options[:templates]
+        klass
       end
     end
 
+    # Called when you `register Mustache::Sinatra` in your Sinatra app.
     def self.registered(app)
       app.helpers Mustache::Sinatra::Helpers
-      app.set :mustaches, app.views
-      app.set :namespace, app
     end
   end
 end

data/lib/mustache/template.rb

@@ -1,46 +1,34 @@
 require 'cgi'
 
+require 'mustache/parser'
+require 'mustache/generator'
+
 class Mustache
-  # A Template is a compiled version of a Mustache template.
+  # A Template represents a Mustache template. It compiles and caches
+  # a raw string template into something usable.
   #
   # The idea is this: when handed a Mustache template, convert it into
   # a Ruby string by transforming Mustache tags into interpolated
   # Ruby.
   #
-  # You shouldn't use this class directly.
+  # You shouldn't use this class directly, instead:
+  #
+  # >> Mustache.render(template, hash)
   class Template
-    # An UnclosedSection error is thrown when a {{# section }} is not
-    # closed.
-    #
-    # For example:
-    #   {{# open }} blah {{/ close }}
-    class UnclosedSection < RuntimeError
-      attr_reader :message
-
-      # Report the line number of the offending unclosed section.
-      def initialize(source, matching_line, unclosed_section)
-        num = 0
-
-        source.split("\n").each_with_index do |line, i|
-          num = i + 1
-          break if line.strip == matching_line.strip
-        end
-
-        @message = "line #{num}: ##{unclosed_section.strip} is not closed"
-      end
-    end
-
     # Expects a Mustache template as a string along with a template
     # path, which it uses to find partials.
-    def initialize(source, template_path = '.', template_extension = 'mustache')
+    def initialize(source)
       @source = source
-      @template_path = template_path
-      @template_extension = template_extension
       @tmpid = 0
     end
 
     # Renders the `@source` Mustache template using the given
     # `context`, which should be a simple hash keyed with symbols.
+    #
+    # The first time a template is rendered, this method is overriden
+    # and from then on it is "compiled". Subsequent calls will skip
+    # the compilation step and run the Ruby version of the template
+    # directly.
     def render(context)
       # Compile our Mustache template into a Ruby string
       compiled = "def render(ctx) #{compile} end"
@@ -57,115 +45,13 @@ class Mustache
     # Does the dirty work of transforming a Mustache template into an
     # interpolation-friendly Ruby string.
     def compile(src = @source)
-      "\"#{compile_sections(src)}\""
+      Generator.new.compile(tokens)
     end
     alias_method :to_s, :compile
 
-    # {{#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 =~ /#{otag}\#([^\}]*)#{ctag}\s*(.+?)#{otag}\/\1#{ctag}\s*/m
-        # $` = The string to the left of the last successful match
-        res << compile_tags($`)
-        name = $1.strip.to_sym.inspect
-        code = compile($2)
-        res << ev(<<-compiled)
-        if v = ctx[#{name}]
-          v = [v] unless v.is_a?(Array) # shortcut when passed non-array
-          v.map { |h| ctx.push(h); c = #{code}; ctx.pop; c }.join
-        end
-        compiled
-        # $' = The string to the right of the last successful match
-        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 =~ /#{otag}(#|=|!|<|>|&|\{)?(.+?)\1?#{ctag}+/m
-        res << str($`)
-        case $1
-        when '#'
-          # Unclosed section - raise an error and
-          # report the line number
-          raise UnclosedSection.new(@source, $&, $2)
-        when '!'
-          # ignore comments
-        when '='
-          self.otag, self.ctag = $2.strip.split(' ', 2)
-        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)
-      name = name.to_s.to_sym.inspect
-      ev("ctx.partial(#{name})")
-    end
-
-    # Generate a temporary id, used when compiling code.
-    def tmpid
-      @tmpid += 1
-    end
-
-    # Get a (hopefully) literal version of an object, sans quotes
-    def str(s)
-      s.inspect[1..-2]
-    end
-
-    # {{ - opening tag delimiter
-    def otag
-      @otag ||= Regexp.escape('{{')
-    end
-
-    def otag=(tag)
-      @otag = Regexp.escape(tag)
-    end
-
-    # }} - closing tag delimiter
-    def ctag
-      @ctag ||= Regexp.escape('}}')
-    end
-
-    def ctag=(tag)
-      @ctag = Regexp.escape(tag)
-    end
-
-    # {{}} - an escaped tag
-    def etag(s)
-      ev("CGI.escapeHTML(ctx[#{s.strip.to_sym.inspect}].to_s)")
-    end
-
-    # {{{}}} - an unescaped tag
-    # Aliased as & - {{&name}}
-    def utag(s)
-      ev("ctx[#{s.strip.to_sym.inspect}]")
-    end
-
-    # An interpolation-friendly version of a string, for use within a
-    # Ruby string.
-    def ev(s)
-      "#\{#{s}}"
+    # Returns an array of tokens for a given template.
+    def tokens(src = @source)
+      Parser.new.compile(src)
     end
   end
 end

data/lib/mustache/version.rb

@@ -1,3 +1,3 @@
 class Mustache
-  Version = '0.7.0'
+  Version = '0.9.0'
 end

data/man/mustache.1

@@ -7,7 +7,13 @@
 \fBmustache\fR \-\- Mustache processor
 .
 .SH "SYNOPSIS"
-\fBcat data.yml template.mustache | mustache\fR
+.
+.nf
+mustache <YAML> <FILE>
+mustache \-\-compile <FILE>
+mustache \-\-tokens <FILE>
+.
+.fi
 .
 .SH "DESCRIPTION"
 Mustache is a logic\-less templating system for HTML, config files,
@@ -107,6 +113,25 @@ Hi scott!
 .
 .IP "" 0
 .
+.SH "OPTIONS"
+By default \fBmustache\fR will try to render a Mustache template using the
+YAML frontmatter you provide. It can do a few other things, however.
+.
+.TP
+\fB\-c\fR, \fB\-\-compile\fR
+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.
+.
+.TP
+\fB\-t\fR, \fB\-\-tokens\fR
+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.
+.
 .SH "INSTALLATION"
 If you have RubyGems installed:
 .
@@ -119,6 +144,21 @@ gem install mustache
 .
 .IP "" 0
 .
+.SH "EXAMPLES"
+.
+.nf
+$ mustache data.yml template.mustache
+$ cat data.yml | mustache \- template.mustache
+$ mustache \-c template.mustache
+$ cat <<data | druby mustache \- template.mustache
+\-\-\-
+name: Bob
+age: 30
+\-\-\-
+data
+.
+.fi
+.
 .SH "COPYRIGHT"
 Mustache is Copyright (C) 2009 Chris Wanstrath
 .

data/man/mustache.1.html

@@ -67,7 +67,10 @@
 
 <h2>SYNOPSIS</h2>
 
-<p><code>cat data.yml template.mustache | mustache</code></p>
+<pre><code>mustache &lt;YAML> &lt;FILE>
+mustache --compile &lt;FILE>
+mustache --tokens &lt;FILE>
+</code></pre>
 
 <h2>DESCRIPTION</h2>
 
@@ -140,6 +143,24 @@ Hi mark!
 Hi scott!
 </code></pre>
 
+<h2>OPTIONS</h2>
+
+<p>By default <code>mustache</code> will try to render a Mustache template using the
+YAML frontmatter you provide. It can do a few other things, however.</p>
+
+<dl>
+<dt><code>-c</code>, <code>--compile</code></dt><dd><p>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.</p></dd>
+<dt><code>-t</code>, <code>--tokens</code></dt><dd><p>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.</p></dd>
+</dl>
+
+
 <h2>INSTALLATION</h2>
 
 <p>If you have RubyGems installed:</p>
@@ -147,6 +168,19 @@ Hi scott!
 <pre><code>gem install mustache
 </code></pre>
 
+<h2>EXAMPLES</h2>
+
+<pre><code>$ mustache data.yml template.mustache
+$ cat data.yml | mustache - template.mustache
+$ mustache -c template.mustache
+$ cat &lt;&lt;data | druby mustache - template.mustache
+---
+name: Bob
+age: 30
+---
+data
+</code></pre>
+
 <h2>COPYRIGHT</h2>
 
 <p>Mustache is Copyright (C) 2009 Chris Wanstrath</p>

data/man/mustache.1.ron

@@ -3,7 +3,9 @@ mustache(1) -- Mustache processor
 
 ## SYNOPSIS
 
-`cat data.yml template.mustache | mustache`
+    mustache <YAML> <FILE>
+    mustache --compile <FILE>
+    mustache --tokens <FILE>
 
 
 ## DESCRIPTION
@@ -73,6 +75,24 @@ For example:
     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
 
@@ -81,6 +101,19 @@ 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

data/test/fixtures/delimiters.mustache

@@ -1,6 +1,8 @@
 {{=<% %>=}}
-* <% first %>
+* <% start %>
 <%=| |=%>
-* | second |
+|# middle |
+* | item |
+|/ middle |
 |={{ }}=|
-* {{ third }}
+* {{ final }}

data/test/fixtures/delimiters.rb

@@ -4,16 +4,17 @@ require 'mustache'
 class Delimiters < Mustache
   self.path = File.dirname(__FILE__)
 
-  def first
+  def start
     "It worked the first time."
   end
 
-  def second
-    "And it worked the second time."
+  def middle
+    [ { :item => "And it worked the second time." },
+      { :item => "As well as the third." } ]
   end
 
-  def third
-    "Then, surprisingly, it worked the third time."
+  def final
+    "Then, surprisingly, it worked the final time."
   end
 end
 

data/test/mustache_test.rb

@@ -108,8 +108,9 @@ end_simple
 * It worked the first time.
 
 * And it worked the second time.
+* As well as the third.
 
-* Then, surprisingly, it worked the third time.
+* Then, surprisingly, it worked the final time.
 end_template
   end
 
@@ -203,9 +204,12 @@ data
     instance[:list] = [ :item => 1234 ]
     instance.template = '{{#list}} <li>{{item}}</li> {{/gist}}'
 
-    assert_raise Mustache::Template::UnclosedSection do
+    begin
       instance.render
+    rescue => e
     end
+
+    assert e.message.include?('Unclosed section')
   end
 
   def test_unclosed_sections_reports_the_line_number
@@ -218,7 +222,7 @@ data
     rescue => e
     end
 
-    assert e.message.include?('line 3')
+    assert e.message.include?('Line 3')
   end
 
   def test_enumerable_sections_accept_a_hash_as_a_context
@@ -300,8 +304,63 @@ data
     assert instance.compiled?
   end
 
-  def test_compile
-    assert_equal '"Hi, #{CGI.escapeHTML(ctx[:person].to_s)}!"',
-      Mustache.compile("Hi, {{person}}!")
+  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 = <<template
+{{#items}}
+start
+{{#items}}
+  {{a}}
+{{/items}}
+end
+{{/items}}
+template
+
+    data = {
+      "items" => [
+        { "items" => [ {"a" => 1}, {"a" => 2}, {"a" => 3} ] },
+        { "items" => [ {"a" => 4}, {"a" => 5}, {"a" => 6} ] },
+        { "items" => [ {"a" => 7}, {"a" => 8}, {"a" => 9} ] }
+      ]
+    }
+
+    assert_equal <<expected, Mustache.render(template, data)
+start
+1
+2
+3
+end
+start
+4
+5
+6
+end
+start
+7
+8
+9
+end
+expected
   end
 end

data/test/parser_test.rb

@@ -0,0 +1,54 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'helper'
+
+class ParserTest < Test::Unit::TestCase
+  def test_parser
+    lexer = Mustache::Parser.new
+    tokens = lexer.compile(<<-EOF)
+<h1>{{header}}</h1>
+{{#items}}
+{{#first}}
+  <li><strong>{{name}}</strong></li>
+{{/first}}
+{{#link}}
+  <li><a href="{{url}}">{{name}}</a></li>
+{{/link}}
+{{/items}}
+
+{{#empty}}
+<p>The list is empty.</p>
+{{/empty}}
+EOF
+
+    expected = [:multi,
+      [:static, "<h1>"],
+      [:mustache, :etag, "header"],
+      [:static, "</h1>\n"],
+      [:mustache,
+        :section,
+        "items",
+        [:multi,
+          [:mustache,
+            :section,
+            "first",
+            [:multi,
+              [:static, "<li><strong>"],
+              [:mustache, :etag, "name"],
+              [:static, "</strong></li>\n"]]],
+          [:mustache,
+            :section,
+            "link",
+            [:multi,
+              [:static, "<li><a href=\""],
+              [:mustache, :etag, "url"],
+              [:static, "\">"],
+              [:mustache, :etag, "name"],
+              [:static, "</a></li>\n"]]]]],
+      [:mustache,
+        :section,
+        "empty",
+        [:multi, [:static, "<p>The list is empty.</p>\n"]]]]
+
+    assert_equal expected, tokens
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mustache
 version: !ruby/object:Gem::Version 
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors: 
 - Chris Wanstrath
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-08 00:00:00 -08:00
+date: 2010-03-26 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -38,6 +38,8 @@ files:
 - Rakefile
 - LICENSE
 - lib/mustache/context.rb
+- lib/mustache/generator.rb
+- lib/mustache/parser.rb
 - lib/mustache/sinatra.rb
 - lib/mustache/template.rb
 - lib/mustache/version.rb
@@ -87,6 +89,7 @@ files:
 - test/fixtures/unescaped.rb
 - test/helper.rb
 - test/mustache_test.rb
+- test/parser_test.rb
 - test/partial_test.rb
 has_rdoc: true
 homepage: http://github.com/defunkt/mustache