mustache 0.99.5 → 0.99.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1a22fd6d24b05a356ea96d520d05b1d558789a55
-  data.tar.gz: 434c410c4f8eec4c004ce4dce27d9cc7e6e8d03a
+  metadata.gz: e3c1091a71418634c3e493d6b3aae1e5a8f0d0f0
+  data.tar.gz: 87936c1b015243222b2c95c29693106a9ea646a1
 SHA512:
-  metadata.gz: 3fddf352c8e8ec2303c451a834a3ed437de4dacffe211ff55f64a165dcef9692a972f2346cb6bd272fcfecccc58fef762f055a8f7c19bc74e627c851ba5321db
-  data.tar.gz: 091b121190a804a7d003f762b08f2ab287811ed94f3642233fcda90773affee179bc69de7132b159dae3da4cd5f4c7928cefb3d2ea49a2333038c046993c1a9a
+  metadata.gz: a422377f6020f923eac84ca194e46b78d05ad611428faa4dede440c090c61e2a30d5d15618286ae72b8ebf486e9aae4b351fee521f5bdc4e13ecc99d1a1677e4
+  data.tar.gz: 30d05bc44030071c322a18ff64235c7bd8da19b03c1cbb4bc68dd3deba33c21d82af75dc435aa2c9845705ea8c7989130aa7626aced0ffb119d6bc18344fa420

data/README.md

@@ -8,7 +8,7 @@ As ctemplates says, "It emphasizes separating logic from presentation:
 it is impossible to embed application logic in this template language."
 
 For a list of implementations (other than Ruby) and tips, see
-<http://mustache.github.com/>.
+<http://mustache.github.io/>.
 
 
 Overview
@@ -99,16 +99,16 @@ Tag Types
 
 For a language-agnostic overview of Mustache's template syntax, see
 the `mustache(5)` manpage or
-<http://mustache.github.com/mustache.5.html>.
+<http://mustache.github.io/mustache.5.html>.
 
 
 Escaping
 --------
 
 Mustache does escape all values when using the standard double
-Mustache syntax. Characters which will be escaped: `& \ " < >`. To
-disable escaping, simply use triple mustaches like
-`{{{unescaped_variable}}}`.
+Mustache syntax. Characters which will be escaped: `& \ " < >` (as 
+well as `'` in Ruby `>= 2.0`). To disable escaping, simply use triple
+mustaches like `{{{unescaped_variable}}}`.
 
 Example: Using `{{variable}}` inside a template for `5 > 2` will
 result in `5 &gt; 2`, where as the usage of `{{{variable}}}` will
@@ -283,16 +283,16 @@ Sinatra
 
 Mustache ships with Sinatra integration. Please see
 `lib/mustache/sinatra.rb` or
-<http://github.com/defunkt/mustache/blob/master/lib/mustache/sinatra.rb>
+<https://github.com/defunkt/mustache/blob/master/lib/mustache/sinatra.rb>
 for complete documentation.
 
 An example Sinatra application is also provided:
-<http://github.com/defunkt/mustache-sinatra-example>
+<https://github.com/defunkt/mustache-sinatra-example>
 
 If you are upgrading to Sinatra 1.0 and Mustache 0.9.0+ from Mustache
 0.7.0 or lower, the settings have changed. But not that much.
 
-See [this diff](http://gist.github.com/345490) for what you need to
+See [this diff](https://gist.github.com/defunkt/345490) for what you need to
 do. Basically, things are named properly now and all should be
 contained in a hash set using `set :mustache, hash`.
 
@@ -317,11 +317,7 @@ Using Rails? Add this to your initializer or environment file:
 Vim
 ---
 
-Thanks to [Juvenn Woo](http://github.com/juvenn) for mustache.vim. It
-is included under the contrib/ directory.
-
-See <http://gist.github.com/323622> for installation instructions.
-
+vim-mustache-handlebars is available at https://github.com/mustache/vim-mustache-handlebars
 
 Emacs
 -----
@@ -332,16 +328,16 @@ mustache-mode.el is available at https://github.com/mustache/emacs
 TextMate
 --------
 
-[Mustache.tmbundle](http://github.com/defunkt/Mustache.tmbundle)
+[Mustache.tmbundle](https://github.com/defunkt/Mustache.tmbundle)
 
-See <http://gist.github.com/323624> for installation instructions.
+See <https://gist.github.com/defunkt/323624> for installation instructions.
 
 
 Command Line
 ------------
 
 See `mustache(1)` man page or
-<http://mustache.github.com/mustache.1.html>
+<http://mustache.github.io/mustache.1.html>
 for command line docs.
 
 
@@ -356,8 +352,8 @@ Installation
 Acknowledgements
 ----------------
 
-Thanks to [Tom Preston-Werner](http://github.com/mojombo) for showing
-me ctemplate and [Leah Culver](http://github.com/leah) for the name "Mustache."
+Thanks to [Tom Preston-Werner](https://github.com/mojombo) for showing
+me ctemplate and [Leah Culver](https://github.com/leah) for the name "Mustache."
 
 Special thanks to [Magnus Holm](http://judofyr.net/) for all his
 awesome work on Mustache's parser.
@@ -391,9 +387,9 @@ The archive can be found at <http://librelist.com/browser/>.
 Meta
 ----
 
-* Code: `git clone git://github.com/defunkt/mustache.git`
-* Home: <http://mustache.github.com>
-* Bugs: <http://github.com/defunkt/mustache/issues>
+* Code: `git clone https://github.com/defunkt/mustache.git`
+* Home: <http://mustache.github.io>
+* Bugs: <https://github.com/defunkt/mustache/issues>
 * List: <mustache@librelist.com>
 * Gems: <http://rubygems.org/gems/mustache>
 
@@ -402,8 +398,8 @@ You can also find us in `#{` on irc.freenode.net.
 [1]: http://code.google.com/p/google-ctemplate/
 [2]: http://www.ivan.fomichev.name/2008/05/erlang-template-engine-prototype.html
 [3]: http://google-ctemplate.googlecode.com/svn/trunk/doc/howto.html
-[4]: http://github.com/brynary/rack-bug/
+[4]: https://github.com/brynary/rack-bug/
 [5]: http://img.skitch.com/20091027-n8pxwwx8r61tc318a15q1n6m14.png
 [cb]: http://wiki.github.com/defunkt/resque/contributing
 [fk]: http://help.github.com/forking/
-[is]: http://github.com/defunkt/mustache/issues
+[is]: https://github.com/defunkt/mustache/issues

data/Rakefile

@@ -1,5 +1,5 @@
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 
 #
 # Helpers

data/bin/mustache

@@ -64,20 +64,38 @@ class Mustache
       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
+    def self.yaml_is_array?(yaml)
+        yaml.is_a? Array and yaml.length == 1 and yaml[0].is_a? Array
+    end
 
-      if doc =~ /^(\s*---(.+)---\s*)/m
-        yaml = $2.strip
-        template = doc.sub($1, '')
+    def self.yaml_is_object?(yaml)
+        yaml.is_a? Array and yaml.length == 1 and yaml[0].is_a? Hash
+    end
 
-        YAML.each_document(yaml) do |data|
-          puts Mustache.render(template, data)
-        end
-      else
+    # Does the dirty work of reading files from the command line then
+    # processing them. The meat of this script, if you will.
+    def self.process_files(input_files)
+      doc = input_files.file.read
+
+      yaml = nil
+      begin
+        yaml = RUBY_VERSION >= '1.9.3' ? YAML.load_stream(doc) : YAML.each_document(doc)
+      rescue
+        puts "Unable to parse yaml!"
+      end
+
+      if yaml.nil?
         puts Mustache.render(doc)
+      else
+        template = input_files.skip.file.read
+
+        if self.yaml_is_array?(yaml)
+          puts Mustache.render(template, yaml[0].reduce({}) {|hash, currentHash| hash.merge(currentHash)})
+        elsif self.yaml_is_object?(yaml)
+          puts Mustache.render(template, yaml[0])
+        else
+          puts Mustache.render(template, yaml)
+        end
       end
     end
   end
@@ -89,6 +107,6 @@ ARGV << '-h' if ARGV.empty? && $stdin.tty?
 # Process options
 Mustache::CLI.parse_options(ARGV) if $stdin.tty?
 
-# Still here - process ARGF
+# Still here - process rest of ARGF
 Mustache::CLI.process_files(ARGF)
 

data/lib/mustache.rb

@@ -1,3 +1,4 @@
+require 'mustache/enumerable'
 require 'mustache/template'
 require 'mustache/context'
 require 'mustache/settings'
@@ -202,14 +203,10 @@ class Mustache
   #   Mustache.view_namespace = Hurl::Views
   #   Mustache.view_class(:Partial) # => Hurl::Views::Partial
   def self.view_class(name)
-    if name != classify(name.to_s)
-      name = classify(name.to_s)
-    end
+    name = classify(name.to_s)
 
     # Emptiness begets emptiness.
-    if name.to_s == ''
-      return Mustache
-    end
+    return Mustache if name.to_s == ''
 
     file_name = underscore(name)
     name = "#{view_namespace}::#{name}"
@@ -280,11 +277,7 @@ class Mustache
   # Turns a string into a Mustache::Template. If passed a Template,
   # returns it.
   def self.templateify(obj)
-    if obj.is_a?(Template)
-      obj
-    else
-      Template.new(obj.to_s)
-    end
+    obj.is_a?(Template) ? obj : Template.new(obj.to_s)
   end
 
   def templateify(obj)

data/lib/mustache/blah.rb

@@ -0,0 +1,116 @@
+require 'mustache'
+
+class Mustache::Template
+  def token_names
+    def recursor(toks, section)
+      toks.map do |token|
+        next unless token.is_a? Array
+        if token[0] == :mustache && [:etag,:utag].include? token[1]
+          (section + [token[2][2][0]]).join '.'
+        elsif token[0] == :mustache && [:section,:inverted_section].include? token[1]
+          recursor(token[4], section + [token[2][2][0]])
+        else
+          recursor(token, section)
+        end
+      end
+    end
+    recursor(tokens, []).flatten.reject(&:nil?).uniq
+  end
+
+  def section_names
+    def recursor(toks, section)
+      sections = []
+      toks.each do |token|
+        next unless token.is_a? Array
+        if token[0] == :mustache && [:section,:inverted_section].include? token[1]
+          new_section = section + [token[2][2][0]]
+          sections += [ new_section.join('.') ] + recursor(token[4], new_section)
+        else
+          sections += recursor(token, section)
+        end
+      end
+      sections
+    end
+    recursor(tokens,[]).reject(&:nil?).uniq
+  end
+
+  def partial_names
+    def recursor(toks)
+      partials = []
+      toks.each do |token|
+        next unless token.is_a? Array
+        partials += if token[0..1] == [:mustache, :partial]
+          [token[2]] # partial here
+        else
+          recursor(token)
+        end
+      end
+      partials
+    end
+    recursor(tokens).reject(&:nil?).uniq
+  end
+
+end
+
+if __FILE__ == $0
+  require "test/unit"
+
+  class TestMustacheTokenNames < Test::Unit::TestCase
+
+    def setup
+      @template = Mustache::Template.new(@@template_text ||= DATA.read)
+    end
+
+    def test_token_names
+      assert_equal(@template.token_names,
+        [ "yourname",
+          "HOME",
+          "friend.name",
+          "friend.morr.word",
+          "friend.morr.up",
+          "friend.morr.awesomesauce",
+          "friend.morr.hiss",
+          "friend.notinmorr",
+          "friend.person",
+          "love",
+          "triplestash"
+        ]
+      )
+    end
+
+    def test_partial_names
+      assert_equal(@template.partial_names, ["partial1", "partial2"])
+    end
+
+    def test_section_names
+      assert_equal(@template.section_names, ["friend", "friend.morr"])
+    end
+  end
+end
+
+__END__
+Hi there {{yourname}}.  Your home directory is {{HOME}}.
+
+{{#friend}}
+Your friend is named {{name}}
+  {{#morr}}
+   Hey {{word}} {{up}} {{{awesomesauce}}}.
+   {{/morr}}
+   {{^morr}}
+   Booooo.  {{hiss}}
+   {{/morr}}
+   {{notinmorr}}
+   {{> partial1}}
+{{/friend}}
+{{^friend}}
+You have no friends, {{person}}.  You suck.
+{{/friend}}
+
+{{> partial2}}
+{{! comments are awesome }}
+
+{{={% %}=}}
+
+{%love%}
+{%={{ }}=%}
+{{{triplestash}}}

data/lib/mustache/context.rb

@@ -31,7 +31,7 @@ class Mustache
       part = mustache.partial(name).to_s.gsub(/^/, indentation)
 
       # Call the Mustache's `partial` method and render the result.
-      result = mustache.render(part, self)
+      mustache.render(part, self)
     end
 
     # Find the first Mustache in the stack. If we're being rendered
@@ -80,7 +80,7 @@ class Mustache
     # Do we know about a particular key? In other words, will calling
     # `context[key]` give us a result that was set. Basically.
     def has_key?(key)
-      !!fetch(key)
+      !!fetch(key, false)
     rescue ContextMiss
       false
     end
@@ -97,9 +97,7 @@ class Mustache
         next if frame == self
 
         value = find(frame, name, :__missing)
-        if value != :__missing
-          return value
-        end
+        return value if value != :__missing
       end
 
       if default == :__raise || mustache_in_stack.raise_on_context_miss?
@@ -121,22 +119,37 @@ class Mustache
     #
     # 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?)
+      hash = obj.respond_to?(:to_hash)
+
+      if !hash
+        # If a class, we need to find tags (methods) per Parser::ALLOWED_CONTENT.
+        if key.to_s.include?('-')
+          key = key.to_s.gsub('-', '_')
+        end
 
-      if hash && obj.has_key?(key)
+        if obj.respond_to?(key)
+          meth = obj.method(key) rescue proc { obj.send(key) }
+          if meth.arity == 1
+            meth.to_proc
+          else
+            meth[]
+          end
+        else
+          default
+        end
+      elsif 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) rescue proc { obj.send(key) }
-        if meth.arity == 1
-          meth.to_proc
-        else
-          meth[]
-        end
       else
-        default
+        obj[key] || default
       end
     end
   end
 end
+
+class Hash
+  def to_hash
+    self
+  end unless method_defined?(:to_hash)
+end

data/lib/mustache/enumerable.rb

@@ -0,0 +1,3 @@
+class Mustache
+  Enumerable = Module.new
+end

data/lib/mustache/generator.rb

@@ -64,17 +64,22 @@ class Mustache
     #
     #   [:multi,
     #    [:static, "Hello "],
-    #    [:mustache, :etag, "name"],
+    #    [:mustache, :etag,
+    #     [:mustache, :fetch, ["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"]]]]
+    #   [:mustache, :etag,
+    #    [:mustache, :fetch, ["value"]]],
+    #   [:static, "!\n"],
+    #   [:mustache,
+    #    :section,
+    #    [:mustache, :fetch, ["in_ca"]],
+    #   [:multi,
+    #    [:static, "Well, $"],
+    #    [:mustache, :etag,
+    #     [:mustache, :fetch, ["taxed_value"]]],
+    #    [:static, ", after taxes.\n"]],
+    #    "Well, ${{taxed_value}}, after taxes.\n",
+    #    ["{{", "}}"]]]
     def compile!(exp)
       case exp.first
       when :multi
@@ -111,7 +116,7 @@ class Mustache
           t.render(ctx.dup)
         else
           # Shortcut when passed non-array
-          v = [v] unless v.is_a?(Array) || defined?(Enumerator) && v.is_a?(Enumerator)
+          v = [v] unless v.is_a?(Array) || v.is_a?(Mustache::Enumerable) || defined?(Enumerator) && v.is_a?(Enumerator)
 
           v.map { |h| ctx.push(h); r = #{code}; ctx.pop; r }.join
         end