mustache 0.98.0 → 0.99.0

data/Rakefile

@@ -30,14 +30,6 @@ else
   end
 end
 
-if command? :kicker
-  desc "Launch Kicker (like autotest)"
-  task :kicker do
-    puts "Kicking... (ctrl+c to cancel)"
-    exec "kicker -e rake test lib examples"
-  end
-end
-
 
 #
 # Ron
@@ -76,12 +68,6 @@ end
 # Documentation
 #
 
-begin
-  require 'sdoc_helpers'
-rescue LoadError
-  warn "sdoc support not enabled. Please gem install sdoc-helpers."
-end
-
 desc "Publish to GitHub Pages"
 task :pages => [ "man:build" ] do
   Dir['man/*.html'].each do |f|

data/lib/mustache/context.rb

@@ -12,8 +12,6 @@ class Mustache
   # A Context represents the context which a Mustache template is
   # executed within. All Mustache tags reference keys in the Context.
   class Context
-    attr_accessor :frame, :key
-
     # Expect to be passed an instance of `Mustache`.
     def initialize(mustache)
       @stack = [mustache]
@@ -94,34 +92,51 @@ class Mustache
     # If no second parameter is passed (or raise_on_context_miss is
     # set to true), will raise a ContextMiss exception on miss.
     def fetch(name, default = :__raise)
-      @key = name
-
       @stack.each do |frame|
         # Prevent infinite recursion.
         next if frame == self
-        @frame = frame
-
-        # Is this frame a hash?
-        hash = frame.respond_to?(:has_key?)
-
-        if hash && frame.has_key?(name)
-          return frame[name]
-        elsif hash && frame.has_key?(name.to_s)
-          @key = name.to_s
-          return frame[name.to_s]
-        elsif !hash && frame.respond_to?(name)
-          @frame = nil
-          return frame.__send__(name)
+
+        value = find(frame, name, :__missing)
+        if value != :__missing
+          return value
         end
       end
 
-      @frame = @key = nil
-
       if default == :__raise || mustache_in_stack.raise_on_context_miss?
         raise ContextMiss.new("Can't find #{name} in #{@stack.inspect}")
       else
         default
       end
     end
+
+    # Finds a key in an object, using whatever method is most
+    # appropriate. If the object is a hash, does a simple hash lookup.
+    # If it's an object that responds to the key as a method call,
+    # invokes that method. You get the idea.
+    #
+    #     obj - The object to perform the lookup on.
+    #     key - The key whose value you want.
+    # default - An optional default value, to return if the
+    #           key is not found.
+    #
+    # Returns the value of key in obj if it is found and default otherwise.
+    def find(obj, key, default = nil)
+      hash = obj.respond_to?(:has_key?)
+
+      if hash && obj.has_key?(key)
+        obj[key]
+      elsif hash && obj.has_key?(key.to_s)
+        obj[key.to_s]
+      elsif !hash && obj.respond_to?(key)
+        meth = obj.method(key)
+        if meth.arity == 1
+          meth.to_proc
+        else
+          meth[]
+        end
+      else
+        default
+      end
+    end
   end
 end

data/lib/mustache/generator.rb

@@ -98,7 +98,7 @@ class Mustache
       # 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 = #{compile!(name)}
         if v == true
           #{code}
         elsif v.is_a?(Proc)
@@ -123,7 +123,7 @@ class Mustache
       # Compile the Ruby for this inverted section now that we know
       # what's inside.
       ev(<<-compiled)
-      v = ctx[#{name.to_sym.inspect}]
+      v = #{compile!(name)}
       if v.nil? || v == false || v.respond_to?(:empty?) && v.empty?
         #{code}
       end
@@ -140,9 +140,10 @@ class Mustache
     # An unescaped tag.
     def on_utag(name)
       ev(<<-compiled)
-        v = ctx[#{name.to_sym.inspect}]
-        v = Mustache::Template.new(v.call.to_s).render(ctx.dup) if v.is_a?(Proc)
-        ctx.frame[ctx.key] = v if ctx.frame.is_a?(Hash)
+        v = #{compile!(name)}
+        if v.is_a?(Proc)
+          v = Mustache::Template.new(v.call.to_s).render(ctx.dup)
+        end
         v.to_s
       compiled
     end
@@ -150,13 +151,31 @@ class Mustache
     # An escaped tag.
     def on_etag(name)
       ev(<<-compiled)
-        v = ctx[#{name.to_sym.inspect}]
-        v = Mustache::Template.new(v.call.to_s).render(ctx.dup) if v.is_a?(Proc)
-        ctx.frame[ctx.key] = v if ctx.frame.is_a?(Hash)
+        v = #{compile!(name)}
+        if v.is_a?(Proc)
+          v = Mustache::Template.new(v.call.to_s).render(ctx.dup)
+        end
         ctx.escapeHTML(v.to_s)
       compiled
     end
 
+    def on_fetch(names)
+      names = names.map { |n| n.to_sym }
+
+      if names.length == 0
+        "ctx[:to_s]"
+      elsif names.length == 1
+        "ctx[#{names.first.to_sym.inspect}]"
+      else
+        initial, *rest = names
+        <<-compiled
+          #{rest.inspect}.inject(ctx[#{initial.inspect}]) { |value, key|
+            value && ctx.find(value, key)
+          }
+        compiled
+      end
+    end
+
     # An interpolation-friendly version of a string, for use within a
     # Ruby string.
     def ev(s)

data/lib/mustache/parser.rb

@@ -138,17 +138,19 @@ EOF
       # We found {{ but we can't figure out what's going on inside.
       error "Illegal content in tag" if content.empty?
 
+      fetch = [:mustache, :fetch, content.split('.')]
+
       # Based on the sigil, do what needs to be done.
       case type
       when '#'
         block = [:multi]
-        @result << [:mustache, :section, content, block]
+        @result << [:mustache, :section, fetch, block]
         @sections << [content, position, @result]
         @result = block
         last_index = 1
       when '^'
         block = [:multi]
-        @result << [:mustache, :inverted_section, content, block]
+        @result << [:mustache, :inverted_section, fetch, block]
         @sections << [content, position, @result]
         @result = block
         last_index = 1
@@ -172,20 +174,9 @@ EOF
         # The closing } in unescaped tags is just a hack for
         # aesthetics.
         type = "}" if type == "{"
-        @result << [:mustache, :utag, content]
+        @result << [:mustache, :utag, fetch]
       else
-        parts = content.to_s.split(".").reverse
-
-        if parts.size == 0
-          # implicit iterators - {{.}}
-          @result << [:mustache, :etag, "to_s"]
-        else
-          # dot notation - {{person.name}}
-          etag = [:mustache, :etag, parts.shift]
-          @result << parts.inject(etag) { |section, key|
-            [:mustache, :section, key, section, content]
-          }
-        end
+        @result << [:mustache, :etag, fetch]
       end
 
       # Skip whitespace and any balancing sigils after the content

data/lib/mustache/settings.rb

@@ -0,0 +1,226 @@
+# Settings which can be configured for all view classes, a single
+# view class, or a single Mustache instance.
+class Mustache
+
+  #
+  # Template Path
+  #
+
+  # The template path informs your Mustache view where to look for its
+  # corresponding template. By default it's the current directory (".")
+  #
+  # A class named Stat with a template_path of "app/templates" will look
+  # for "app/templates/stat.mustache"
+
+  def self.template_path
+    @template_path ||= inheritable_config_for :template_path, '.'
+  end
+
+  def self.template_path=(path)
+    @template_path = File.expand_path(path)
+    @template = nil
+  end
+
+  def template_path
+    @template_path ||= self.class.template_path
+  end
+
+  def template_path=(path)
+    @template_path = File.expand_path(path)
+    @template = nil
+  end
+
+  # Alias for `template_path`
+  def self.path
+    template_path
+  end
+  alias_method :path, :template_path
+
+  # Alias for `template_path`
+  def self.path=(path)
+    self.template_path = path
+  end
+  alias_method :path=, :template_path=
+
+
+  #
+  # Template Extension
+  #
+
+  # A Mustache template's default extension is 'mustache', but this can be changed.
+
+  def self.template_extension
+    @template_extension ||= inheritable_config_for :template_extension, 'mustache'
+  end
+
+  def self.template_extension=(template_extension)
+    @template_extension = template_extension
+    @template = nil
+  end
+
+  def template_extension
+    @template_extension ||= self.class.template_extension
+  end
+
+  def template_extension=(template_extension)
+    @template_extension = template_extension
+    @template = nil
+  end
+
+
+  #
+  # Template Name
+  #
+
+  # The template name is the Mustache template file without any
+  # extension or other information. Defaults to `class_name`.
+  #
+  # You may want to change this if your class is named Stat but you want
+  # to re-use another template.
+  #
+  #   class Stat
+  #     self.template_name = "graphs" # use graphs.mustache
+  #   end
+
+  def self.template_name
+    @template_name || underscore
+  end
+
+  def self.template_name=(template_name)
+    @template_name = template_name
+    @template = nil
+  end
+
+  def template_name
+    @template_name ||= self.class.template_name
+  end
+
+  def template_name=(template_name)
+    @template_name = template_name
+    @template = nil
+  end
+
+
+  #
+  # Template File
+  #
+
+  # 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}/#{template_name}.#{template_extension}"
+  end
+
+  def self.template_file=(template_file)
+    @template_file = template_file
+    @template = nil
+  end
+
+  # The template file is the absolute path of the file Mustache will
+  # use as its template. By default it's ./class_name.mustache
+  def template_file
+    @template_file || "#{path}/#{template_name}.#{template_extension}"
+  end
+
+  def template_file=(template_file)
+    @template_file = template_file
+    @template = nil
+  end
+
+
+  #
+  # Template
+  #
+
+  # The template is the actual string Mustache uses as its template.
+  # There is a bit of magic here: what we get back is actually a
+  # Mustache::Template object, but you can still safely use `template=`
+  #  with a string.
+
+  def self.template
+    @template ||= templateify(File.read(template_file))
+  end
+
+  def self.template=(template)
+    @template = templateify(template)
+  end
+
+  # The template can be set at the instance level.
+  def template
+    return @template if @template
+
+    # If they sent any instance-level options use that instead of the class's.
+    if @template_path || @template_extension || @template_name || @template_file
+      @template = templateify(File.read(template_file))
+    else
+      @template = self.class.template
+    end
+  end
+
+  def template=(template)
+    @template = templateify(template)
+  end
+
+
+  #
+  # Raise on context miss
+  #
+
+  # Should an exception be raised when we cannot find a corresponding method
+  # or key in the current context? By default this is false to emulate ctemplate's
+  # behavior, but it may be useful to enable when debugging or developing.
+  #
+  # If set to true and there is a context miss, `Mustache::ContextMiss` will
+  # be raised.
+
+  def self.raise_on_context_miss?
+    @raise_on_context_miss
+  end
+
+  def self.raise_on_context_miss=(boolean)
+    @raise_on_context_miss = boolean
+  end
+
+  # Instance level version of `Mustache.raise_on_context_miss?`
+  def raise_on_context_miss?
+    self.class.raise_on_context_miss? || @raise_on_context_miss
+  end
+
+  def raise_on_context_miss=(boolean)
+    @raise_on_context_miss = boolean
+  end
+
+
+  #
+  # View Namespace
+  #
+
+  # The constant under which Mustache will look for views when autoloading.
+  # By default the view namespace is `Object`, but it might be nice to set
+  # it to something like `Hurl::Views` if your app's main namespace is `Hurl`.
+
+  def self.view_namespace
+    @view_namespace ||= inheritable_config_for(:view_namespace, Object)
+  end
+
+  def self.view_namespace=(namespace)
+    @view_namespace = namespace
+  end
+
+
+  #
+  # View Path
+  #
+
+  # Mustache searches the view path for .rb files to require when asked to find a
+  # view class. Defaults to "."
+
+  def self.view_path
+    @view_path ||= inheritable_config_for(:view_path, '.')
+  end
+
+  def self.view_path=(path)
+    @view_path = path
+  end
+end

data/lib/mustache/sinatra.rb

@@ -111,7 +111,7 @@ class Mustache
       end
 
       # Returns a View class for a given template name.
-      def mustache_class(template, options)
+      def mustache_class(template, options = {})
         @template_cache.fetch(:mustache, template) do
           compile_mustache(template, options)
         end
@@ -123,6 +123,10 @@ class Mustache
         options[:templates] ||= settings.views if settings.respond_to?(:views)
         options[:namespace] ||= self.class
 
+        unless options[:namespace].to_s.include? 'Views'
+          options[:namespace] = options[:namespace].const_get(:Views)
+        end
+
         factory = Class.new(Mustache) do
           self.view_namespace = options[:namespace]
           self.view_path      = options[:views]
@@ -137,6 +141,8 @@ class Mustache
         # Try to find the view class for a given view, e.g.
         # :view => Hurl::Views::Index.
         klass = factory.view_class(view)
+        klass.view_namespace = options[:namespace]
+        klass.view_path      = options[:views]
 
         # If there is no view class, issue a warning and use the one
         # we just generated to cache the compiled template.

data/lib/mustache/version.rb

@@ -1,3 +1,3 @@
 class Mustache
-  Version = VERSION = '0.98.0'
+  Version = VERSION = '0.99.0'
 end

data/lib/mustache.rb

@@ -1,5 +1,6 @@
 require 'mustache/template'
 require 'mustache/context'
+require 'mustache/settings'
 
 # Mustache is the base class from which your Mustache subclasses
 # should inherit (though it can be used on its own).
@@ -70,6 +71,11 @@ require 'mustache/context'
 # for files containing view classes when using the `view_class` method.
 #
 class Mustache
+
+  #
+  # Public API
+  #
+
   # Instantiates an instance of this class and calls `render` with
   # the passed args.
   #
@@ -78,14 +84,70 @@ class Mustache
     new.render(*args)
   end
 
-  # Alias for `render`
-  def self.to_html(*args)
-    render(*args)
+  class << self
+    alias_method :to_html, :render
+    alias_method :to_text, :render
   end
 
-  # Alias for `render`
-  def self.to_text(*args)
-    render(*args)
+  # Parses our fancy pants template file and returns normal file with
+  # all special {{tags}} and {{#sections}}replaced{{/sections}}.
+  #
+  # data - A String template or a Hash context. If a Hash is given,
+  #        we'll try to figure out the template from the class.
+  #  ctx - A Hash context if `data` is a String template.
+  #
+  # Examples
+  #
+  #   @view.render("Hi {{thing}}!", :thing => :world)
+  #
+  #   View.template = "Hi {{thing}}!"
+  #   @view = View.new
+  #   @view.render(:thing => :world)
+  #
+  # Returns a rendered String version of a template
+  def render(data = template, ctx = {})
+    if data.is_a? Hash
+      ctx = data
+      tpl = templateify(template)
+    elsif data.is_a? Symbol
+      self.template_name = data
+      tpl = templateify(template)
+    else
+      tpl = templateify(data)
+    end
+
+    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
+
+  # Context accessors.
+  #
+  # view = Mustache.new
+  # view[:name] = "Jon"
+  # view.template = "Hi, {{name}}!"
+  # view.render # => "Hi, Jon!"
+  def [](key)
+    context[key.to_sym]
+  end
+
+  def []=(key, value)
+    context[key.to_sym] = value
+  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
 
   # Given a file name and an optional context, attempts to load and
@@ -116,91 +178,23 @@ class Mustache
     self.class.partial(name)
   end
 
-  # The template path informs your Mustache subclass where to look for its
-  # corresponding template. By default it's the current directory (".")
-  def self.template_path
-    @template_path ||= inheritable_config_for :template_path, '.'
-  end
-
-  def self.template_path=(path)
-    @template_path = File.expand_path(path)
-    @template = nil
-  end
-
-  # Alias for `template_path`
-  def self.path
-    template_path
-  end
-
-  # Alias for `template_path`
-  def self.path=(path)
-    self.template_path = path
-  end
-
-  # A Mustache template's default extension is 'mustache'
-  def self.template_extension
-    @template_extension ||= inheritable_config_for :template_extension, 'mustache'
-  end
-
-  def self.template_extension=(template_extension)
-    @template_extension = template_extension
-    @template = nil
-  end
-
-  # The template name is the Mustache template file without any
-  # extension or other information. Defaults to `class_name`.
-  def self.template_name
-    @template_name || underscore
-  end
-
-  def self.template_name=(template_name)
-    @template_name = template_name
-    @template = nil
-  end
-
-  # 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}/#{template_name}.#{template_extension}"
-  end
-
-  def self.template_file=(template_file)
-    @template_file = template_file
-    @template = nil
-  end
-
-  # The template is the actual string Mustache uses as its template.
-  # There is a bit of magic here: what we get back is actually a
-  # Mustache::Template object here, but you can still safely use
-  # `template=` with a string.
-  def self.template
-    @template ||= templateify(File.read(template_file))
-  end
-
-  def self.template=(template)
-    @template = templateify(template)
-  end
-
-  # The constant under which Mustache will look for views. By default it's
-  # `Object`, but it might be nice to set it to something like `Hurl::Views` if
-  # your app's main namespace is `Hurl`.
-  def self.view_namespace
-    @view_namespace ||= inheritable_config_for(:view_namespace, Object)
+  # Override this to provide custom escaping.
+  #
+  # class PersonView < Mustache
+  #   def escapeHTML(str)
+  #     my_html_escape_method(str)
+  #   end
+  # end
+  #
+  # Returns a String
+  def escapeHTML(str)
+    CGI.escapeHTML(str)
   end
 
-  def self.view_namespace=(namespace)
-    @view_namespace = namespace
-  end
 
-  # Mustache searches the view path for .rb files to require when asked to find a
-  # view class. Defaults to "."
-  def self.view_path
-    @view_path ||= inheritable_config_for(:view_path, '.')
-  end
-
-  def self.view_path=(path)
-    @view_path = path
-  end
+  #
+  # Private API
+  #
 
   # When given a symbol or string representing a class, will try to produce an
   # appropriate view class.
@@ -218,38 +212,33 @@ class Mustache
     end
 
     file_name = underscore(name)
-    namespace = view_namespace
+    name = "#{view_namespace}::#{name}"
 
-    if namespace.const_defined?(:Views) && namespace::Views.const_defined?(name)
-      namespace::Views.const_get(name)
-    elsif namespace.const_defined?(name)
-      namespace.const_get(name)
+    if const = const_get!(name)
+      const
     elsif File.exists?(file = "#{view_path}/#{file_name}.rb")
       require "#{file}".chomp('.rb')
-      if namespace.const_defined?(:Views)
-        namespace::Views.const_get(name)
-      else
-        namespace.const_get(name)
-      end
+      const_get!(name) || Mustache
     else
       Mustache
     end
-  rescue NameError
-    Mustache
   end
 
-  # Should an exception be raised when we cannot find a corresponding method
-  # or key in the current context? By default this is false to emulate ctemplate's
-  # behavior, but it may be useful to enable when debugging or developing.
+  # Supercharged version of Module#const_get.
   #
-  # If set to true and there is a context miss, `Mustache::ContextMiss` will
-  # be raised.
-  def self.raise_on_context_miss?
-    @raise_on_context_miss
-  end
-
-  def self.raise_on_context_miss=(boolean)
-    @raise_on_context_miss = boolean
+  # Always searches under Object and can find constants by their full name,
+  #   e.g. Mustache::Views::Index
+  #
+  # name - The full constant name to find.
+  #
+  # Returns the constant if found
+  # Returns nil if nothing is found
+  def self.const_get!(name)
+    name.split('::').inject(Object) do |klass, name|
+      klass.const_get(name)
+    end
+  rescue NameError
+    nil
   end
 
   # Has this template already been compiled? Compilation is somewhat
@@ -264,21 +253,28 @@ class Mustache
   end
 
   # template_partial => TemplatePartial
+  # template/partial => Template::Partial
   def self.classify(underscored)
-    underscored.split(/[-_]/).map do |part|
-      part[0] = part[0].chr.upcase; part
-    end.join
+    underscored.split('/').map do |namespace|
+      namespace.split(/[-_]/).map do |part|
+        part[0] = part[0].chr.upcase; part
+      end.join
+    end.join('::')
   end
 
-  # TemplatePartial => template_partial
+  #   TemplatePartial => template_partial
+  # Template::Partial => template/partial
   # Takes a string but defaults to using the current class' name.
   def self.underscore(classified = name)
     classified = name if classified.to_s.empty?
     classified = superclass.name if classified.to_s.empty?
 
-    string = classified.dup.split('::').last
-    string[0] = string[0].chr.downcase
-    string.gsub(/[A-Z]/) { |s| "_#{s.downcase}"}
+    string = classified.dup.split("#{view_namespace}::").last
+
+    string.split('::').map do |part|
+      part[0] = part[0].chr.downcase
+      part.gsub(/[A-Z]/) { |s| "_#{s.downcase}"}
+    end.join('/')
   end
 
   # Turns a string into a Mustache::Template. If passed a Template,
@@ -291,6 +287,10 @@ class Mustache
     end
   end
 
+  def templateify(obj)
+    self.class.templateify(obj)
+  end
+
   # Return the value of the configuration setting on the superclass, or return
   # the default.
   #
@@ -301,98 +301,4 @@ class Mustache
   def self.inheritable_config_for(attr_name, default)
     superclass.respond_to?(attr_name) ? superclass.send(attr_name) : default
   end
-
-  def templateify(obj)
-    self.class.templateify(obj)
-  end
-
-  # The template can be set at the instance level.
-  def template
-    @template ||= self.class.template
-  end
-
-  def template=(template)
-    @template = templateify(template)
-  end
-
-  # Override this to provide custom escaping.
-  #
-  # class PersonView < Mustache
-  #   def escapeHTML(str)
-  #     my_html_escape_method(str)
-  #   end
-  # end
-  #
-  # Returns a String
-  def escapeHTML(str)
-    CGI.escapeHTML(str)
-  end
-
-  # Instance level version of `Mustache.raise_on_context_miss?`
-  def raise_on_context_miss?
-    self.class.raise_on_context_miss? || @raise_on_context_miss
-  end
-  attr_writer :raise_on_context_miss
-
-  # 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.
-  #
-  # view = Mustache.new
-  # view[:name] = "Jon"
-  # view.template = "Hi, {{name}}!"
-  # view.render # => "Hi, Jon!"
-  def [](key)
-    context[key.to_sym]
-  end
-
-  def []=(key, value)
-    context[key.to_sym] = value
-  end
-
-  # Parses our fancy pants template file and returns normal file with
-  # all special {{tags}} and {{#sections}}replaced{{/sections}}.
-  #
-  # data - A String template or a Hash context. If a Hash is given,
-  #        we'll try to figure out the template from the class.
-  #  ctx - A Hash context if `data` is a String template.
-  #
-  # Examples
-  #
-  #   @view.render("Hi {{thing}}!", :thing => :world)
-  #
-  #   View.template = "Hi {{thing}}!"
-  #   @view = View.new
-  #   @view.render(:thing => :world)
-  #
-  # Returns a rendered String version of a template
-  def render(data = template, ctx = {})
-    if data.is_a? Hash
-      ctx = data
-      tpl = templateify(template)
-    elsif data.is_a? Symbol
-      old_template_name = self.class.template_name
-      self.class.template_name = data
-      tpl = templateify(template)
-      self.class.template_name = old_template_name
-    else
-      tpl = templateify(data)
-    end
-
-    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
 end

data/test/autoloading_test.rb

@@ -37,6 +37,10 @@ class AutoloadingTest < Test::Unit::TestCase
 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)

data/test/fixtures/dot_notation.mustache

@@ -3,4 +3,8 @@
 * {{person.hometown.city}}, {{person.hometown.state}}
 * {{#person}}{{hometown.city}}, {{hometown.state}}{{/person}}
 * {{#person}}{{#hometown}}{{city}}, {{state}}{{/hometown}}{{/person}}
-* {{normal}}
+* {{#person.hometown}}{{city}}, {{state}}{{/person.hometown}}
+* {{normal}}
+
+* {{{person.name.first}}} {{&person.name.last}}
+* {{^person.alien?}}{{person.hometown.city}}, {{person.hometown.state}}{{/person.alien?}}

data/test/mustache_test.rb

@@ -196,10 +196,13 @@ end_section
 
   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
@@ -208,7 +211,12 @@ end_section
   end
 
   def test_namespaced_underscore
-    assert_equal 'stat_stuff', Mustache.underscore('Views::StatStuff')
+    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
@@ -383,6 +391,17 @@ data
     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}}}}"
 
@@ -520,14 +539,30 @@ template
 text
   end
 
+  def test_unescaped_implicit_iterator
+    view = Mustache.new
+    view.template = "{{#people}}* {{{.}}}\n{{/people}}"
+    view[:people] = %w( Chris Mark Scott )
+
+    assert_equal <<text, view.render
+* Chris
+* Mark
+* Scott
+text
+  end
+
   def test_dot_notation
-    assert_equal <<-text.chomp, DotNotation.render
+    assert_equal <<-text, DotNotation.render
 * Chris Firescythe
 * 24
 * Cincinnati, OH
 * Cincinnati, OH
 * Cincinnati, OH
+* Cincinnati, OH
 * Normal
+
+* Chris Firescythe
+* Cincinnati, OH
 text
   end
 

data/test/parser_test.rb

@@ -22,35 +22,35 @@ EOF
 
     expected = [:multi,
       [:static, "<h1>"],
-      [:mustache, :etag, "header"],
+      [:mustache, :etag, [:mustache, :fetch, ["header"]]],
       [:static, "</h1>\n"],
       [:mustache,
         :section,
-        "items",
+        [:mustache, :fetch, ["items"]],
         [:multi,
           [:mustache,
             :section,
-            "first",
+            [:mustache, :fetch, ["first"]],
             [:multi,
               [:static, "  <li><strong>"],
-              [:mustache, :etag, "name"],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]]],
               [:static, "</strong></li>\n"]],
             %Q'  <li><strong>{{name}}</strong></li>\n'],
           [:mustache,
             :section,
-            "link",
+            [:mustache, :fetch, ["link"]],
             [:multi,
               [:static, "  <li><a href=\""],
-              [:mustache, :etag, "url"],
+              [:mustache, :etag, [:mustache, :fetch, ["url"]]],
               [:static, "\">"],
-              [:mustache, :etag, "name"],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]]],
               [:static, "</a></li>\n"]],
             %Q'  <li><a href="{{url}}">{{name}}</a></li>\n']],
         %Q'{{#first}}\n  <li><strong>{{name}}</strong></li>\n{{/first}}\n{{#link}}\n  <li><a href="{{url}}">{{name}}</a></li>\n{{/link}}\n'],
       [:static, "\n"],
       [:mustache,
         :section,
-        "empty",
+        [:mustache, :fetch, ["empty"]],
         [:multi, [:static, "<p>The list is empty.</p>\n"]],
         %Q'<p>The list is empty.</p>\n']]
 

data/test/partial_test.rb

@@ -23,8 +23,8 @@ end_partial
 
   def test_view_partial_inherits_context
     klass = Class.new(TemplatePartial)
-    klass.template_path = File.dirname(__FILE__) + '/fixtures'
     view = klass.new
+    view.template_path = File.dirname(__FILE__) + '/fixtures'
     view[:titles] = [{:title => :One}, {:title => :Two}]
     view.template = <<-end_template
 <h1>Context Test</h1>

metadata

@@ -1,21 +1,23 @@
 --- !ruby/object:Gem::Specification 
 name: mustache
 version: !ruby/object:Gem::Version 
-  hash: 407
+  hash: 403
   prerelease: false
   segments: 
   - 0
-  - 98
+  - 99
   - 0
-  version: 0.98.0
+  version: 0.99.0
 platform: ruby
 authors: 
 - Chris Wanstrath
+- Magnus Holm
+- Pieter van de Bruggen
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-02-24 00:00:00 -08:00
+date: 2011-02-28 00:00:00 -08:00
 default_executable: 
 dependencies: []
 
@@ -46,6 +48,7 @@ files:
 - lib/mustache/context.rb
 - lib/mustache/generator.rb
 - lib/mustache/parser.rb
+- lib/mustache/settings.rb
 - lib/mustache/sinatra.rb
 - lib/mustache/template.rb
 - lib/mustache/version.rb