mustache 0.99.4 → 1.1.3

data/test/mustache_test.rb

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
-$LOAD_PATH.unshift File.dirname(__FILE__)
-require 'helper'
+require_relative 'helper'
+require 'json'
 
-class MustacheTest < Test::Unit::TestCase
+class MustacheTest < Minitest::Test
   def test_instance_render
     klass = Class.new(Mustache)
     klass.template = "Hi {{thing}}!"
@@ -15,7 +15,7 @@ end_simple
   end
 
   def test_passenger
-    assert_equal <<-end_passenger, Passenger.to_text
+    assert_equal <<-end_passenger, Passenger.render
 <VirtualHost *>
   ServerName example.com
   DocumentRoot /var/www/example.com
@@ -66,6 +66,14 @@ end_complex
                  instance.render
   end
 
+  def test_empty_string_as_section_does_not_render_inverted
+    instance = Mustache.new
+    instance[:value] = ""
+    instance.template = "{{#value}}Value Found{{/value}}{{^value}}Value Not Found{{/value}}"
+
+    assert_equal "Value Found", instance.render
+  end
+
   def test_sassy_single_line_sections
     instance = Mustache.new
     instance[:full_time] = true
@@ -279,14 +287,19 @@ data
   RailsEnv production
 </VirtualHost>
 data
-    old_path, Mustache.template_path = Mustache.template_path, File.dirname(__FILE__) + "/fixtures"
-    old_extension, Mustache.template_extension = Mustache.template_extension, "conf"
-
-    assert_equal expected, Mustache.render(:passenger, :stage => 'production',
-                                                       :server => 'example.com',
-                                                       :deploy_to => '/var/www/example.com' )
+    old_path = Mustache.template_path
+    old_extension = Mustache.template_extension
 
-    Mustache.template_path, Mustache.template_extension = old_path, old_extension
+    begin
+      Mustache.template_path = File.dirname(__FILE__) + "/fixtures"
+      Mustache.template_extension = "conf"
+
+      assert_equal expected, Mustache.render(:passenger, :stage => 'production',
+                                                         :server => 'example.com',
+                                                         :deploy_to => '/var/www/example.com')
+    ensure
+      Mustache.template_path, Mustache.template_extension = old_path, old_extension
+    end
   end
 
   def test_doesnt_execute_what_it_doesnt_need_to
@@ -344,6 +357,63 @@ data
     assert_equal ' <li>1234</li> ', instance.render
   end
 
+  def test_enumerable_sections_enumerate_mustache_enumerables
+    person = Struct.new(:name, :age)
+    people_array = []
+    people_array << person.new('Juliet', 13)
+    people_array << person.new('Romeo', 16)
+    people = Class.new do
+      include Enumerable
+      include Mustache::Enumerable
+
+      def initialize array
+        @people = array
+      end
+
+      def each *args, &block
+        @people.each(*args, &block)
+      end
+    end
+
+    view = Mustache.new
+    view[:people] = people.new(people_array)
+    view.template = <<-TEMPLATE
+{{#people}}
+{{name}} is {{age}}
+{{/people}}
+    TEMPLATE
+    assert_equal <<-EXPECTED, view.render
+Juliet is 13
+Romeo is 16
+    EXPECTED
+  end
+
+  def test_enumerable_sections_do_not_enumerate_untagged_enumerables
+    people = Struct.new(:first, :second, :third)
+    person = Struct.new(:name, :age)
+
+    view = Mustache.new
+    view[:people] = people.new(person.new("Mercutio", 17), person.new("Tybalt", 20), person.new("Benvolio", 15))
+    view.template = <<-TEMPLATE
+{{#people}}
+{{#first}}
+{{name}} is {{age}}
+{{/first}}
+{{#second}}
+{{name}} is {{age}}
+{{/second}}
+{{#third}}
+{{name}} is {{age}}
+{{/third}}
+{{/people}}
+    TEMPLATE
+    assert_equal <<-EXPECTED, view.render
+Mercutio is 17
+Tybalt is 20
+Benvolio is 15
+    EXPECTED
+  end
+
   def test_not_found_in_context_renders_empty_string
     instance = Mustache.new
     instance.template = '{{#list}} <li>{{item}}</li> {{/list}}'
@@ -369,10 +439,33 @@ data
     end
   end
 
+  def test_not_found_deep_in_context_raises_when_asked_to
+    instance = Mustache.new
+    instance.raise_on_context_miss = true
+
+    instance[:list] = { :item => { :value => 1234 } }
+
+    instance.template = '{{list.item.no_value}}'
+
+    assert_raises Mustache::ContextMiss do
+      instance.render
+    end
+  end
+
+  def test_found_in_nested_context_when_asked_to_raise
+    instance = Mustache.new
+    instance.raise_on_context_miss = true
+
+    instance[:item] = { :list => [ { :value => 1235, :deep_list => [{:x => 'y'}]}] }
+
+    instance.template = '{{#item.list}}{{#deep_list}}{{value}}{{/deep_list}}{{/item.list}}'
+    assert_equal '1235', instance.render
+  end
+
   def test_knows_when_its_been_compiled_when_set_with_string
     klass = Class.new(Mustache)
 
-    assert ! klass.compiled?
+    refute klass.compiled?
     klass.template = 'Hi, {{person}}!'
     assert klass.compiled?
   end
@@ -381,28 +474,29 @@ data
     klass = Class.new(Simple)
     klass.template_file = File.dirname(__FILE__) + '/fixtures/simple.mustache'
 
-    assert ! klass.compiled?
+    refute klass.compiled?
     klass.render
     assert klass.compiled?
   end
 
   def test_an_instance_knows_when_its_class_is_compiled
-    instance = Simple.new
+    klass = Class.new(Simple)
+    instance = klass.new
 
-    assert ! Simple.compiled?
-    assert ! instance.compiled?
+    refute klass.compiled?, "Simple was already compiled (from class)."
+    refute instance.compiled?, "Simple was already compiled (from instance)."
 
-    Simple.render
+    klass.render
 
-    assert Simple.compiled?
-    assert instance.compiled?
+    assert klass.compiled?, "Simple was not compiled (from class)."
+    assert instance.compiled?, "Simple was not compiled (from instance)."
   end
 
   def test_knows_when_its_been_compiled_at_the_instance_level
     klass = Class.new(Mustache)
     instance = klass.new
 
-    assert ! instance.compiled?
+    refute instance.compiled?
     instance.template = 'Hi, {{person}}!'
     assert instance.compiled?
   end
@@ -421,6 +515,24 @@ data
     assert_equal 1, view.calls
   end
 
+  def test_sections_returning_lambdas_get_called_dynamically_with_text
+    view = Mustache.new
+    view.template       = '{{name}}'
+    view[:name]         = lambda { '{{dynamic_name}}' }
+    view[:dynamic_name] = 'Chris'
+
+    assert_equal "Chris", view.render.chomp
+  end
+
+  def test_sections_returning_lambdas_get_not_called_dynamically_with_text_if_static
+    view = Mustache.new :static_lambdas => true
+    view.template       = '{{name}}'
+    view[:name]         = lambda { '{{dynamic_name}}' }
+    view[:dynamic_name] = 'Chris'
+
+    assert_equal "{{dynamic_name}}", view.render.chomp
+  end
+
   def test_sections_which_refer_to_unary_method_call_them_as_proc
     kls = Class.new(Mustache) do
       def unary_method(arg)
@@ -454,6 +566,12 @@ data
     assert_equal "chris j strath", Mustache.render(template, hash)
   end
 
+  def test_liberal_tag_names_in_class
+    assert_equal <<-end_liberal, Liberal.render
+kevin j sheurs 123 Somewhere St
+end_liberal
+  end
+
   def test_nested_sections_same_names
     template = <<template
 {{#items}}
@@ -550,7 +668,7 @@ template
     assert_equal('[ 0 1 2 3 4 5 6 7 8 9 10 ]', MethodMissing.render)
   end
 
-  def test_custom_escaping
+  def test_custom_html_escaping
     view = Class.new(Mustache) do
       def escapeHTML(str)
         "pong"
@@ -561,6 +679,17 @@ template
     assert_equal 'nothing', Mustache.render("{{thing}}", :thing => "nothing")
   end
 
+  def test_custom_escaping
+    view = Class.new(Mustache) do
+      def escape(str)
+        JSON.dump(str)
+      end
+    end
+
+    assert_equal '{ "key": "a\"b" }', view.render('{ "key": {{thing}} }', :thing => 'a"b')
+    assert_equal 'nothing', Mustache.render("{{thing}}", :thing => "nothing")
+  end
+
   def test_implicit_iterator
     view = Mustache.new
     view.template = "{{#people}}* {{.}}\n{{/people}}"
@@ -605,16 +734,37 @@ text
     base = Class.new(Mustache)
     tmpl = Class.new(base)
 
-    {:template_path      => File.expand_path('./foo'),
-     :template_extension => 'stache',
+    {:template_extension => 'stache',
      :view_namespace     => TestNamespace,
      :view_path          => './foo'
      }.each do |attr, value|
       base.send("#{attr}=", value)
       assert_equal value, tmpl.send(attr)
     end
+    attr = :template_path
+    value = File.expand_path('./foo')
+    base.send("#{attr}=", value)
+    assert_equal value, tmpl.send(attr).first
   end
-    def test_array_of_arrays
+
+  def test_hash_default_proc
+    template = <<template
+{{greetings.Peter}}
+{{greetings.Paul}}
+{{greetings.Mary}}
+template
+    data = {
+      'greetings' => Hash.new { |hash, key| hash[key] = "Hello, #{key}!" }
+    }
+
+    assert_equal <<expected, Mustache.render(template, data)
+Hello, Peter!
+Hello, Paul!
+Hello, Mary!
+expected
+  end
+
+  def test_array_of_arrays
     template = <<template
 {{#items}}
 start
@@ -651,7 +801,8 @@ start
 end
 expected
   end
-      def test_indentation_again
+
+  def test_indentation_again
     template = <<template
 SELECT
   {{#cols}}
@@ -674,4 +825,38 @@ FROM
   DUMMY1
 template
   end
+
+  def test_cast_to_hash_in_context
+    hashlike = Object.new
+    def hashlike.title
+      'title'
+    end
+    def hashlike.to_hash
+      { title: 'title' }
+    end
+
+    template = '%%{{title}}%%'
+
+    assert_equal '%%title%%', Mustache.render(template, hashlike)
+  end
+
+  def test_instance_with_initialize_render
+    klass = Class.new(Mustache) do
+      def initialize(name)
+        super
+        @name = name
+      end
+      attr_reader :name
+    end
+
+    klass.template = "Hi {{name}}!"
+    assert_equal "Hi Dougal!", klass.new("Dougal").render
+  end
+
+  def test_variable_with_at_name
+    instance = Mustache.new
+    instance.template = "\t{{#list@home}}a{{/list@home}}"
+
+    assert_equal "\taa", instance.render(:"list@home" => [1, 2])
+  end
 end

data/test/parser_test.rb

@@ -1,7 +1,21 @@
-$LOAD_PATH.unshift File.dirname(__FILE__)
-require 'helper'
+require_relative 'helper'
+
+class ParserTest < Minitest::Test
+
+  def test_parser_extension
+    parser = Mustache::Parser.new
+    parser.instance_variable_set :@result, 'zomg'
+    Mustache::Parser.add_type(:'@', :'$') do |*args|
+      [:mustache, :at_sign, @result, *args]
+    end
+    assert_match Mustache::Parser.valid_types, '@'
+    assert_match Mustache::Parser.valid_types, '$'
+    assert_equal [:mustache, :at_sign, 'zomg', 1, 2, 3],
+                 parser.send('scan_tag_@', 1, 2, 3)
+    assert_equal [:mustache, :at_sign, 'zomg', 1, 2, 3],
+                 parser.send('scan_tag_$', 1, 2, 3)
+  end
 
-class ParserTest < Test::Unit::TestCase
   def test_parser
     lexer = Mustache::Parser.new
     tokens = lexer.compile(<<-EOF)
@@ -22,29 +36,32 @@ EOF
 
     expected = [:multi,
       [:static, "<h1>"],
-      [:mustache, :etag, [:mustache, :fetch, ["header"]]],
+      [:mustache, :etag, [:mustache, :fetch, ["header"]], [1, 11]],
       [:static, "</h1>\n"],
       [:mustache,
         :section,
         [:mustache, :fetch, ["items"]],
+        [2, 7],
         [:multi,
           [:mustache,
             :section,
             [:mustache, :fetch, ["first"]],
+            [3, 7],
             [:multi,
               [:static, "  <li><strong>"],
-              [:mustache, :etag, [:mustache, :fetch, ["name"]]],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]], [4, 19]],
               [:static, "</strong></li>\n"]],
             %Q'  <li><strong>{{name}}</strong></li>\n',
             %w[{{ }}]],
           [:mustache,
             :section,
             [:mustache, :fetch, ["link"]],
+            [6, 6],
             [:multi,
               [:static, "  <li><a href=\""],
-              [:mustache, :etag, [:mustache, :fetch, ["url"]]],
+              [:mustache, :etag, [:mustache, :fetch, ["url"]], [7, 19]],
               [:static, "\">"],
-              [:mustache, :etag, [:mustache, :fetch, ["name"]]],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]], [7, 29]],
               [:static, "</a></li>\n"]],
             %Q'  <li><a href="{{url}}">{{name}}</a></li>\n',
             %w[{{ }}]]],
@@ -54,6 +71,7 @@ EOF
       [:mustache,
         :section,
         [:mustache, :fetch, ["empty"]],
+        [11, 7],
         [:multi, [:static, "<p>The list is empty.</p>\n"]],
         %Q'<p>The list is empty.</p>\n',
         %w[{{ }}]]]
@@ -69,10 +87,75 @@ EOF
       [:mustache,
         :section,
         [:mustache, :fetch, ["list"]],
+        [1, 6],
         [:multi, [:static, "\t"]],
         "\t",
         %w[{{ }}]]]
 
     assert_equal expected, tokens
   end
+
+  def test_unclosed_section
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{#list}}")
+    end
+
+    expected = <<-EOF
+Unclosed section "list"
+  Line 1
+    {{#list}}
+          ^
+EOF
+
+    assert_equal expected, exception.message
+  end
+
+  def test_closing_unopened
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{/list}}")
+    end
+
+    expected = <<-EOF
+Closing unopened "list"
+  Line 1
+    {{/list}}
+          ^
+EOF
+
+    assert_equal expected, exception.message
+  end
+
+  def test_unclosed_tag
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{list")
+    end
+
+    expected = <<-EOF
+Unclosed tag
+  Line 1
+    {{list
+         ^
+EOF
+
+    assert_equal expected, exception.message
+  end
+
+  def test_illegal_content
+    lexer = Mustache::Parser.new
+    exception = assert_raises Mustache::Parser::SyntaxError do
+      lexer.compile("{{")
+    end
+
+    expected = <<-EOF
+Illegal content in tag
+  Line 1
+    {{
+     ^
+EOF
+
+    assert_equal expected, exception.message
+  end
 end

data/test/partial_test.rb

@@ -1,7 +1,6 @@
-$LOAD_PATH.unshift File.dirname(__FILE__)
-require 'helper'
+require_relative 'helper'
 
-class PartialTest < Test::Unit::TestCase
+class PartialTest < Minitest::Test
   def test_view_partial
     assert_equal <<-end_partial.strip, PartialWithModule.render
 <h1>Welcome</h1>
@@ -21,6 +20,19 @@ end_partial
     assert_equal "Again, success!", view.render
   end
 
+  def test_partial_inlining
+    view = Mustache.new :inline_partials_at_compile_time => true
+    view.template = '{{> test/fixtures/inner_partial}}'
+    view[:title] = 'success'
+
+    # Test the rendered result first
+    assert_equal "Again, success!", view.render
+
+    # Now the template should be compiled.
+    # There should be no :partial instruction as the partial has been in-lined.
+    assert_equal false, view.template.tokens.flatten.include?(:partial)
+  end
+
   def test_view_partial_inherits_context
     klass = Class.new(TemplatePartial)
     view = klass.new
@@ -87,7 +99,7 @@ Welcome
 end_partial
   end
 
-  def test_recursive_paritals
+  def test_recursive_partials
     assert_equal <<-end_partial, Recursive.render
 It works!
 end_partial

data/test/path_test.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+require_relative 'helper'
+
+class MustacheTest < Minitest::Test
+
+  def test_default_path
+    assert_instance_of Array, Mustache.template_path
+    assert_equal 1, Mustache.template_path.size
+    assert_includes Mustache.template_path, Dir.pwd
+  end
+
+  def test_set_multiple_paths
+    old_path = Mustache.template_path
+    Mustache.template_path = "this#{File::PATH_SEPARATOR}that"
+    assert_instance_of Array, Mustache.template_path
+    assert_equal 2, Mustache.template_path.size
+    Mustache.template_path = old_path
+  end
+
+  def test_override_found
+
+    expected = <<-data
+<VirtualHost *>
+  ServerAdmin override@mustache.com
+  ServerName example.com
+  DocumentRoot /var/www/example.com
+  RailsEnv production
+</VirtualHost>
+data
+    old_path = Mustache.template_path
+    old_extension = Mustache.template_extension
+
+    begin
+      base = File.dirname(__FILE__)
+      Mustache.template_extension = "conf"
+      Mustache.template_path = "#{base}/fixtures/override:#{base}/fixtures"
+      assert_equal expected, Mustache.render(:passenger, :stage => 'production',
+                                                         :server => 'example.com',
+                                                         :deploy_to => '/var/www/example.com')
+      Mustache.template_path = "#{base}/fixtures:#{base}/fixtures/override"
+      refute_equal expected, Mustache.render(:passenger, :stage => 'production',
+                                                         :server => 'example.com',
+                                                         :deploy_to => '/var/www/example.com')
+    ensure
+      Mustache.template_path, Mustache.template_extension = old_path, old_extension
+    end
+  end
+
+end

data/test/spec_test.rb

@@ -1,16 +1,16 @@
 require 'mustache'
 require 'tmpdir'
 require 'yaml'
-require 'test/unit'
+require 'minitest/autorun'
 
-# Automatically process !code types into Proc objects
-YAML::add_builtin_type('code') { |_, val| eval(val['ruby']) }
+# Calls appropriate method on YAML. See: https://gist.github.com/tenderlove/958999ab4240b93bd3cd
+YAML.add_domain_type(nil, 'code') { |_, val| eval(val['ruby']) }
 
 # A simple base class for Mustache specs.
 # Creates a partials directory, then points a (dynamic) subclass of Mustache at
 # that directory before each test; the partials directory is destroyed after
 # each test is run.
-class MustacheSpec < Test::Unit::TestCase
+class MustacheSpec < Minitest::Test
   def setup
     @partials = File.join(File.dirname(__FILE__), 'partials')
     Dir.mkdir(@partials)
@@ -59,7 +59,7 @@ Dir[spec_files].each do |file|
 
   test_suite.class_eval do
     spec['tests'].each do |test|
-      define_method :"test - #{test['name']}" do
+      define_method :"test_spec - #{test['name']}" do
         setup_partials(test)
         assert_mustache_spec(test)
       end

data/test/template_test.rb

@@ -1,7 +1,6 @@
-$LOAD_PATH.unshift File.dirname(__FILE__)
-require 'helper'
+require_relative 'helper'
 
-class TemplateTest < Test::Unit::TestCase
+class TemplateTest < Minitest::Test
   def test_compile
     assert_equal %("foo"), Mustache::Template.new("foo").compile
   end
@@ -18,3 +17,36 @@ class TemplateTest < Test::Unit::TestCase
     assert_equal [:multi, [:static, "bar"]], Mustache::Template.new("foo").tokens("bar")
   end
 end
+
+class TemplateTest2 < Minitest::Test
+  def setup
+    @@template_text ||= File.read(File.dirname(__FILE__) + "/fixtures/simply_complicated.mustache")
+    @template = Mustache::Template.new(@@template_text)
+  end
+
+  def test_tags
+    assert_equal [
+      "yourname",
+      "HOME",
+      "friend.name",
+      "friend.morr.word",
+      "friend.morr.up",
+      "friend.morr.awesomesauce",
+      "friend.morr.hiss",
+      "friend.notinmorr",
+      "friend.person",
+      "love",
+      "triplestash"
+      ], @template.tags
+  end
+
+  def test_partials
+    assert_equal ["partial1", "partial2"], @template.partials
+  end
+
+  def test_sections
+    assert_equal ["friend", "friend.morr"], @template.sections
+  end
+end
+
+