mustache-bibanon 0.99.5

data/test/parser_test.rb

@@ -0,0 +1,78 @@
+$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, [:mustache, :fetch, ["header"]]],
+      [:static, "</h1>\n"],
+      [:mustache,
+        :section,
+        [:mustache, :fetch, ["items"]],
+        [:multi,
+          [:mustache,
+            :section,
+            [:mustache, :fetch, ["first"]],
+            [:multi,
+              [:static, "  <li><strong>"],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]]],
+              [:static, "</strong></li>\n"]],
+            %Q'  <li><strong>{{name}}</strong></li>\n',
+            %w[{{ }}]],
+          [:mustache,
+            :section,
+            [:mustache, :fetch, ["link"]],
+            [:multi,
+              [:static, "  <li><a href=\""],
+              [:mustache, :etag, [:mustache, :fetch, ["url"]]],
+              [:static, "\">"],
+              [:mustache, :etag, [:mustache, :fetch, ["name"]]],
+              [:static, "</a></li>\n"]],
+            %Q'  <li><a href="{{url}}">{{name}}</a></li>\n',
+            %w[{{ }}]]],
+        %Q'{{#first}}\n  <li><strong>{{name}}</strong></li>\n{{/first}}\n{{#link}}\n  <li><a href="{{url}}">{{name}}</a></li>\n{{/link}}\n',
+        %w[{{ }}]],
+      [:static, "\n"],
+      [:mustache,
+        :section,
+        [:mustache, :fetch, ["empty"]],
+        [:multi, [:static, "<p>The list is empty.</p>\n"]],
+        %Q'<p>The list is empty.</p>\n',
+        %w[{{ }}]]]
+
+    assert_equal expected, tokens
+  end
+
+  def test_raw_content_and_whitespace
+    lexer = Mustache::Parser.new
+    tokens = lexer.compile("{{#list}}\t{{/list}}")
+
+    expected = [:multi,
+      [:mustache,
+        :section,
+        [:mustache, :fetch, ["list"]],
+        [:multi, [:static, "\t"]],
+        "\t",
+        %w[{{ }}]]]
+
+    assert_equal expected, tokens
+  end
+end

data/test/partial_test.rb

@@ -0,0 +1,168 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'helper'
+
+class PartialTest < Test::Unit::TestCase
+  def test_view_partial
+    assert_equal <<-end_partial.strip, PartialWithModule.render
+<h1>Welcome</h1>
+Hello Bob
+You have just won $100000!
+
+<h3>Fair enough, right?</h3>
+end_partial
+  end
+
+  def test_partial_with_slashes
+    klass = Class.new(Mustache)
+    klass.template = '{{> test/fixtures/inner_partial}}'
+    view = klass.new
+    view[:title] = 'success'
+
+    assert_equal "Again, success!", view.render
+  end
+
+  def test_view_partial_inherits_context
+    klass = Class.new(TemplatePartial)
+    view = klass.new
+    view.template_path = File.dirname(__FILE__) + '/fixtures'
+    view[:titles] = [{:title => :One}, {:title => :Two}]
+    view.template = <<-end_template
+<h1>Context Test</h1>
+<ul>
+{{#titles}}
+<li>{{>inner_partial}}</li>
+{{/titles}}
+</ul>
+end_template
+    assert_equal <<-end_partial, view.render
+<h1>Context Test</h1>
+<ul>
+<li>Again, One!</li>
+<li>Again, Two!</li>
+</ul>
+end_partial
+  end
+
+  def test_view_partial_inherits_context_of_class_methods
+    klass = Class.new(TemplatePartial)
+    klass.template_path = File.dirname(__FILE__) + '/fixtures'
+    klass.send(:define_method, :titles) do
+      [{:title => :One}, {:title => :Two}]
+    end
+    view = klass.new
+    view.template = <<-end_template
+<h1>Context Test</h1>
+<ul>
+{{#titles}}
+<li>{{>inner_partial}}</li>
+{{/titles}}
+</ul>
+end_template
+    assert_equal <<-end_partial, view.render
+<h1>Context Test</h1>
+<ul>
+<li>Again, One!</li>
+<li>Again, Two!</li>
+</ul>
+end_partial
+  end
+
+  def test_template_partial
+    assert_equal <<-end_partial.strip, TemplatePartial.render
+<h1>Welcome</h1>
+Again, Welcome!
+end_partial
+  end
+
+  def test_template_partial_with_custom_extension
+    partial = Class.new(TemplatePartial)
+    partial.template_extension = 'txt'
+    partial.template_path = File.dirname(__FILE__) + '/fixtures'
+
+    assert_equal <<-end_partial.strip, partial.render.strip
+Welcome
+-------
+
+## Again, Welcome! ##
+end_partial
+  end
+
+  def test_recursive_paritals
+    assert_equal <<-end_partial, Recursive.render
+It works!
+end_partial
+  end
+
+  def test_crazy_recursive_partials
+    assert_equal <<-end_partial.strip, CrazyRecursive.render
+<html>
+  <body>
+    <ul>
+      <li>
+        1
+        <ul>
+          <li>
+            2
+            <ul>
+              <li>
+                3
+                <ul>
+                </ul>
+              </li>
+            </ul>
+          </li>
+          <li>
+            4
+            <ul>
+              <li>
+                5
+                <ul>
+                  <li>
+                    6
+                    <ul>
+                    </ul>
+                  </li>
+                </ul>
+              </li>
+            </ul>
+          </li>
+        </ul>
+      </li>
+    </ul>
+  </body>
+</html>
+end_partial
+  end
+
+  def test_partials_use_proper_context
+    assert_equal "OuterThing OuterThing", OuterThing.render('{{name}} {{> p}}')
+
+    assert_equal "InnerThing InnerThing", InnerThing.render('{{name}} {{> p}}')
+
+    assert_equal "OuterThing InnerThing InnerThing",
+      OuterThing.render('{{name}} {{#inner}}{{name}} {{> p}}{{/inner}}')
+  end
+
+  def test_partials_render_returned_strings
+    assert_equal "ok", MiddleThing.render('{{> some_partial }}')
+  end
+end
+
+class InnerThing < Mustache
+  def partial(p) self.class end
+  def name;      self.class end
+end
+
+class OuterThing < Mustache
+  def inner
+    InnerThing.new
+  end
+
+  def partial(p) self.class end
+  def name;      self.class end
+end
+
+class MiddleThing < Mustache
+  def partial(name) "{{#{name}}}" end
+  def some_partial; "ok" end
+end

data/test/spec_test.rb

@@ -0,0 +1,68 @@
+require 'mustache'
+require 'tmpdir'
+require 'yaml'
+require 'test/unit'
+
+# Automatically process !code types into Proc objects
+YAML::add_builtin_type('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
+  def setup
+    @partials = File.join(File.dirname(__FILE__), 'partials')
+    Dir.mkdir(@partials)
+
+    @Mustache = Class.new(Mustache)
+    @Mustache.template_path = @partials
+  end
+
+  def teardown
+    Dir[File.join(@partials, '*')].each { |file| File.delete(file) }
+    Dir.rmdir(@partials)
+  end
+
+  # Extracts the partials from the test, and dumps them into the partials
+  # directory for inclusion.
+  def setup_partials(test)
+    (test['partials'] || {}).each do |name, content|
+      File.open(File.join(@partials, "#{name}.mustache"), 'w') do |f|
+        f.print(content)
+      end
+    end
+  end
+
+  # Asserts equality between the rendered template and the expected value,
+  # printing additional context data on failure.
+  def assert_mustache_spec(test)
+    actual = @Mustache.render(test['template'], test['data'])
+
+    assert_equal test['expected'], actual, "" <<
+      "#{ test['desc'] }\n" <<
+      "Data: #{ test['data'].inspect }\n" <<
+      "Template: #{ test['template'].inspect }\n" <<
+      "Partials: #{ (test['partials'] || {}).inspect }\n"
+  end
+
+  def test_noop; assert(true); end
+end
+
+spec_files = File.join(File.dirname(__FILE__), '..', 'ext', 'spec', 'specs', '*.yml')
+Dir[spec_files].each do |file|
+  spec = YAML.load_file(file)
+
+  klass_name = "Test" + File.basename(file, ".yml").sub(/~/, '').capitalize
+  instance_eval "class ::#{klass_name} < MustacheSpec; end"
+  test_suite = Kernel.const_get(klass_name)
+
+  test_suite.class_eval do
+    spec['tests'].each do |test|
+      define_method :"test - #{test['name']}" do
+        setup_partials(test)
+        assert_mustache_spec(test)
+      end
+    end
+  end
+end

data/test/template_test.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift File.dirname(__FILE__)
+require 'helper'
+
+class TemplateTest < Test::Unit::TestCase
+  def test_compile
+    assert_equal %("foo"), Mustache::Template.new("foo").compile
+  end
+
+  def test_compile_with_source
+    assert_equal %("bar"), Mustache::Template.new("foo").compile("bar")
+  end
+
+  def test_token
+    assert_equal [:multi, [:static, "foo"]], Mustache::Template.new("foo").tokens
+  end
+
+  def test_token_with_source
+    assert_equal [:multi, [:static, "bar"]], Mustache::Template.new("foo").tokens("bar")
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: mustache-bibanon
+version: !ruby/object:Gem::Version 
+  hash: 409
+  prerelease: 
+  segments: 
+  - 0
+  - 99
+  - 5
+  version: 0.99.5
+platform: ruby
+authors: 
+- Chris Wanstrath
+- Magnus Holm
+- Pieter van de Bruggen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-02-05 00:00:00 Z
+dependencies: []
+
+description: |
+  Inspired by ctemplate, Mustache is a framework-agnostic way to render
+  logic-free views.
+  
+  As ctemplates says, "It emphasizes separating logic from presentation:
+  it is impossible to embed application logic in this template
+  language.
+  
+  Think of Mustache as a replacement for your views. Instead of views
+  consisting of ERB or HAML with random helpers and arbitrary logic,
+  your views are broken into two parts: a Ruby class and an HTML
+  template.
+
+email: chris@ozmm.org
+executables: 
+- mustache
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- LICENSE
+- lib/rack/bug/panels/mustache_panel.rb
+- lib/rack/bug/panels/mustache_panel/mustache_extension.rb
+- lib/rack/bug/panels/mustache_panel/view.mustache
+- lib/mustache/settings.rb
+- lib/mustache/template.rb
+- lib/mustache/sinatra.rb
+- lib/mustache/parser.rb
+- lib/mustache/generator.rb
+- lib/mustache/version.rb
+- lib/mustache/context.rb
+- lib/mustache.rb
+- bin/mustache
+- man/mustache.5.html
+- man/mustache.1.ron
+- man/mustache.1
+- man/mustache.5.ron
+- man/mustache.5
+- man/mustache.1.html
+- test/template_test.rb
+- test/mustache_test.rb
+- test/fixtures/crazy_recursive.mustache
+- test/fixtures/crazy_recursive.rb
+- test/fixtures/nested_objects.mustache
+- test/fixtures/utf8_partial.mustache
+- test/fixtures/simple.rb
+- test/fixtures/partial_with_module.mustache
+- test/fixtures/partial_with_module.rb
+- test/fixtures/namespaced.rb
+- test/fixtures/delimiters.mustache
+- test/fixtures/inverted_section.rb
+- test/fixtures/recursive.rb
+- test/fixtures/inverted_section.mustache
+- test/fixtures/passenger.rb
+- test/fixtures/complex_view.mustache
+- test/fixtures/unescaped.mustache
+- test/fixtures/complex_view.rb
+- test/fixtures/unescaped.rb
+- test/fixtures/comments.rb
+- test/fixtures/node.mustache
+- test/fixtures/template_partial.rb
+- test/fixtures/dot_notation.rb
+- test/fixtures/utf8.mustache
+- test/fixtures/template_partial.txt
+- test/fixtures/nested_objects.rb
+- test/fixtures/passenger.conf
+- test/fixtures/namespaced.mustache
+- test/fixtures/escaped.rb
+- test/fixtures/inner_partial.txt
+- test/fixtures/simple.mustache
+- test/fixtures/inner_partial.mustache
+- test/fixtures/recursive.mustache
+- test/fixtures/double_section.rb
+- test/fixtures/dot_notation.mustache
+- test/fixtures/template_partial.mustache
+- test/fixtures/lambda.rb
+- test/fixtures/method_missing.rb
+- test/fixtures/delimiters.rb
+- test/fixtures/lambda.mustache
+- test/fixtures/comments.mustache
+- test/fixtures/double_section.mustache
+- test/fixtures/escaped.mustache
+- test/parser_test.rb
+- test/helper.rb
+- test/autoloading_test.rb
+- test/partial_test.rb
+- test/spec_test.rb
+homepage: http://github.com/defunkt/mustache
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Mustache is a framework-agnostic way to render logic-free views.
+test_files: []
+