challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/tilt-1.4.1/test/tilt_stringtemplate_test.rb

@@ -0,0 +1,170 @@
+require 'contest'
+require 'tilt'
+
+class StringTemplateTest < Test::Unit::TestCase
+  test "registered for '.str' files" do
+    assert_equal Tilt::StringTemplate, Tilt['test.str']
+  end
+
+  test "loading and evaluating templates on #render" do
+    template = Tilt::StringTemplate.new { |t| "Hello World!" }
+    assert_equal "Hello World!", template.render
+  end
+
+  test "can be rendered more than once" do
+    template = Tilt::StringTemplate.new { |t| "Hello World!" }
+    3.times { assert_equal "Hello World!", template.render }
+  end
+
+  test "passing locals" do
+    template = Tilt::StringTemplate.new { 'Hey #{name}!' }
+    assert_equal "Hey Joe!", template.render(Object.new, :name => 'Joe')
+  end
+
+  test "evaluating in an object scope" do
+    template = Tilt::StringTemplate.new { 'Hey #{@name}!' }
+    scope = Object.new
+    scope.instance_variable_set :@name, 'Joe'
+    assert_equal "Hey Joe!", template.render(scope)
+  end
+
+  test "passing a block for yield" do
+    template = Tilt::StringTemplate.new { 'Hey #{yield}!' }
+    assert_equal "Hey Joe!", template.render { 'Joe' }
+    assert_equal "Hey Moe!", template.render { 'Moe' }
+  end
+
+  test "multiline templates" do
+    template = Tilt::StringTemplate.new { "Hello\nWorld!\n" }
+    assert_equal "Hello\nWorld!\n", template.render
+  end
+
+  test "backtrace file and line reporting without locals" do
+    data = File.read(__FILE__).split("\n__END__\n").last
+    fail unless data[0] == ?<
+    template = Tilt::StringTemplate.new('test.str', 11) { data }
+    begin
+      template.render
+      fail 'should have raised an exception'
+    rescue => boom
+      assert_kind_of NameError, boom
+      line = boom.backtrace.grep(/^test\.str:/).first
+      assert line, "Backtrace didn't contain test.str"
+      file, line, meth = line.split(":")
+      assert_equal '13', line
+    end
+  end
+
+  test "backtrace file and line reporting with locals" do
+    data = File.read(__FILE__).split("\n__END__\n").last
+    fail unless data[0] == ?<
+    template = Tilt::StringTemplate.new('test.str', 1) { data }
+    begin
+      template.render(nil, :name => 'Joe', :foo => 'bar')
+      fail 'should have raised an exception'
+    rescue => boom
+      assert_kind_of RuntimeError, boom
+      line = boom.backtrace.first
+      file, line, meth = line.split(":")
+      assert_equal 'test.str', file
+      assert_equal '6', line
+    end
+  end
+end
+
+
+class CompiledStringTemplateTest < Test::Unit::TestCase
+  def teardown
+    GC.start
+  end
+
+  class Scope
+  end
+
+  test "compiling template source to a method" do
+    template = Tilt::StringTemplate.new { |t| "Hello World!" }
+    template.render(Scope.new)
+    method = template.send(:compiled_method, [])
+    assert_kind_of UnboundMethod, method
+  end
+
+  test "loading and evaluating templates on #render" do
+    template = Tilt::StringTemplate.new { |t| "Hello World!" }
+    assert_equal "Hello World!", template.render(Scope.new)
+  end
+
+  test "passing locals" do
+    template = Tilt::StringTemplate.new { 'Hey #{name}!' }
+    assert_equal "Hey Joe!", template.render(Scope.new, :name => 'Joe')
+    assert_equal "Hey Moe!", template.render(Scope.new, :name => 'Moe')
+  end
+
+  test "evaluating in an object scope" do
+    template = Tilt::StringTemplate.new { 'Hey #{@name}!' }
+    scope = Scope.new
+    scope.instance_variable_set :@name, 'Joe'
+    assert_equal "Hey Joe!", template.render(scope)
+    scope.instance_variable_set :@name, 'Moe'
+    assert_equal "Hey Moe!", template.render(scope)
+  end
+
+  test "passing a block for yield" do
+    template = Tilt::StringTemplate.new { 'Hey #{yield}!' }
+    assert_equal "Hey Joe!", template.render(Scope.new) { 'Joe' }
+    assert_equal "Hey Moe!", template.render(Scope.new) { 'Moe' }
+  end
+
+  test "multiline templates" do
+    template = Tilt::StringTemplate.new { "Hello\nWorld!\n" }
+    assert_equal "Hello\nWorld!\n", template.render(Scope.new)
+  end
+
+
+  test "template with '}'" do
+    template = Tilt::StringTemplate.new { "Hello }" }
+    assert_equal "Hello }", template.render
+  end
+
+  test "backtrace file and line reporting without locals" do
+    data = File.read(__FILE__).split("\n__END__\n").last
+    fail unless data[0] == ?<
+    template = Tilt::StringTemplate.new('test.str', 11) { data }
+    begin
+      template.render(Scope.new)
+      fail 'should have raised an exception'
+    rescue => boom
+      assert_kind_of NameError, boom
+      line = boom.backtrace.first
+      line = boom.backtrace.grep(/^test\.str:/).first
+      assert line, "Backtrace didn't contain test.str"
+      file, line, meth = line.split(":")
+      assert_equal '13', line
+    end
+  end
+
+  test "backtrace file and line reporting with locals" do
+    data = File.read(__FILE__).split("\n__END__\n").last
+    fail unless data[0] == ?<
+    template = Tilt::StringTemplate.new('test.str') { data }
+    begin
+      template.render(Scope.new, :name => 'Joe', :foo => 'bar')
+      fail 'should have raised an exception'
+    rescue => boom
+      assert_kind_of RuntimeError, boom
+      line = boom.backtrace.first
+      file, line, meth = line.split(":")
+      assert_equal 'test.str', file
+      assert_equal '6', line
+    end
+  end
+end
+
+__END__
+<html>
+<body>
+  <h1>Hey #{name}!</h1>
+
+
+  <p>#{fail}</p>
+</body>
+</html>

data/vendor/bundle/gems/tilt-1.4.1/test/tilt_template_test.rb

@@ -0,0 +1,323 @@
+# coding: utf-8
+require 'contest'
+require 'tilt'
+require 'tempfile'
+
+class TiltTemplateTest < Test::Unit::TestCase
+
+  class MockTemplate < Tilt::Template
+    def prepare
+    end
+  end
+
+  test "needs a file or block" do
+    assert_raise(ArgumentError) { Tilt::Template.new }
+  end
+
+  test "initializing with a file" do
+    inst = MockTemplate.new('foo.erb') {}
+    assert_equal 'foo.erb', inst.file
+  end
+
+  test "initializing with a file and line" do
+    inst = MockTemplate.new('foo.erb', 55) {}
+    assert_equal 'foo.erb', inst.file
+    assert_equal 55, inst.line
+  end
+
+  test "initializing with a tempfile" do
+    tempfile = Tempfile.new('tilt_template_test')
+    inst = MockTemplate.new(tempfile)
+    assert_equal File.basename(tempfile.path), inst.basename
+  end
+
+  class SillyHash < Hash
+    def path(arg)
+    end
+  end
+
+  test "initialize with hash that implements #path" do
+    options = SillyHash[:key => :value]
+    inst = MockTemplate.new(options) {}
+    assert_equal :value, inst.options[:key]
+  end
+
+  test "uses correct eval_file" do
+    inst = MockTemplate.new('foo.erb', 55) {}
+    assert_equal 'foo.erb', inst.eval_file
+  end
+
+  test "uses a default filename for #eval_file when no file provided" do
+    inst = MockTemplate.new { 'Hi' }
+    assert_not_nil inst.eval_file
+    assert !inst.eval_file.include?("\n")
+  end
+
+  test "calculating template's #basename" do
+    inst = MockTemplate.new('/tmp/templates/foo.html.erb') {}
+    assert_equal 'foo.html.erb', inst.basename
+  end
+
+  test "calculating the template's #name" do
+    inst = MockTemplate.new('/tmp/templates/foo.html.erb') {}
+    assert_equal 'foo', inst.name
+  end
+
+  test "initializing with a data loading block" do
+    MockTemplate.new { |template| "Hello World!" }
+  end
+
+  class InitializingMockTemplate < Tilt::Template
+    @@initialized_count = 0
+    def self.initialized_count
+      @@initialized_count
+    end
+
+    def initialize_engine
+      @@initialized_count += 1
+    end
+
+    def prepare
+    end
+  end
+
+  test "one-time template engine initialization" do
+    assert_nil InitializingMockTemplate.engine_initialized
+    assert_equal 0, InitializingMockTemplate.initialized_count
+
+    InitializingMockTemplate.new { "Hello World!" }
+    assert InitializingMockTemplate.engine_initialized
+    assert_equal 1, InitializingMockTemplate.initialized_count
+
+    InitializingMockTemplate.new { "Hello World!" }
+    assert_equal 1, InitializingMockTemplate.initialized_count
+  end
+
+  class PreparingMockTemplate < Tilt::Template
+    include Test::Unit::Assertions
+    def prepare
+      assert !data.nil?
+      @prepared = true
+    end
+    def prepared? ; @prepared ; end
+  end
+
+  test "raises NotImplementedError when #prepare not defined" do
+    assert_raise(NotImplementedError) { Tilt::Template.new { |template| "Hello World!" } }
+  end
+
+  test "raises NotImplementedError when #evaluate or #template_source not defined" do
+    inst = PreparingMockTemplate.new { |t| "Hello World!" }
+    assert_raise(NotImplementedError) { inst.render }
+    assert inst.prepared?
+  end
+
+  class SimpleMockTemplate < PreparingMockTemplate
+    include Test::Unit::Assertions
+    def evaluate(scope, locals, &block)
+      assert prepared?
+      assert !scope.nil?
+      assert !locals.nil?
+      "<em>#{@data}</em>"
+    end
+  end
+
+  test "prepares and evaluates the template on #render" do
+    inst = SimpleMockTemplate.new { |t| "Hello World!" }
+    assert_equal "<em>Hello World!</em>", inst.render
+    assert inst.prepared?
+  end
+
+  class SourceGeneratingMockTemplate < PreparingMockTemplate
+    def precompiled_template(locals)
+      "foo = [] ; foo << %Q{#{data}} ; foo.join"
+    end
+  end
+
+  test "template_source with locals" do
+    inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{name}!' }
+    assert_equal "Hey Joe!", inst.render(Object.new, :name => 'Joe')
+    assert inst.prepared?
+  end
+
+  test "template_source with locals of strings" do
+    inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{name}!' }
+    assert_equal "Hey Joe!", inst.render(Object.new, 'name' => 'Joe')
+    assert inst.prepared?
+  end
+
+  test "template_source with locals having non-variable keys raises error" do
+    inst = SourceGeneratingMockTemplate.new { |t| '1 + 2 = #{_answer}' }
+    err = assert_raise(RuntimeError) { inst.render(Object.new, 'ANSWER' => 3) }
+    assert_equal "invalid locals key: \"ANSWER\" (keys must be variable names)", err.message
+    assert_equal "1 + 2 = 3", inst.render(Object.new, '_answer' => 3)
+  end
+
+  class CustomGeneratingMockTemplate < PreparingMockTemplate
+    def precompiled_template(locals)
+      data
+    end
+
+    def precompiled_preamble(locals)
+      options.fetch(:preamble)
+    end
+
+    def precompiled_postamble(locals)
+      options.fetch(:postamble)
+    end
+  end
+
+  test "supports pre/postamble" do
+    inst = CustomGeneratingMockTemplate.new(
+      :preamble => 'buf = []',
+      :postamble => 'buf.join'
+    ) { 'buf << 1' }
+
+    assert_equal "1", inst.render
+  end
+
+  # Special-case for Haml
+  # https://github.com/rtomayko/tilt/issues/193
+  test "supports Array pre/postambles" do
+    inst = CustomGeneratingMockTemplate.new(
+      :preamble => ['buf = ', '[]'],
+      :postamble => ['buf.', 'join']
+    ) { 'buf << 1' }
+
+    # TODO: Use assert_output when we swicth to MiniTest
+    warns = <<-EOF
+precompiled_preamble should return String (not Array)
+precompiled_postamble should return String (not Array)
+EOF
+
+    begin
+      require 'stringio'
+      $stderr = StringIO.new
+      assert_equal "1", inst.render
+      assert_equal warns, $stderr.string
+    ensure
+      $stderr = STDERR
+    end
+  end
+
+  class Person
+    CONSTANT = "Bob"
+
+    attr_accessor :name
+    def initialize(name)
+      @name = name
+    end
+  end
+
+  test "template_source with an object scope" do
+    inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{@name}!' }
+    scope = Person.new('Joe')
+    assert_equal "Hey Joe!", inst.render(scope)
+  end
+
+  test "template_source with a block for yield" do
+    inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{yield}!' }
+    assert_equal "Hey Joe!", inst.render(Object.new){ 'Joe' }
+  end
+
+  test "template which accesses a constant" do
+    inst = SourceGeneratingMockTemplate.new { |t| 'Hey #{CONSTANT}!' }
+    assert_equal "Hey Bob!", inst.render(Person.new("Joe"))
+  end
+
+  ##
+  # Encodings
+
+  class DynamicMockTemplate < MockTemplate
+    def precompiled_template(locals)
+      options[:code]
+    end
+  end
+
+  class UTF8Template < MockTemplate
+    def default_encoding
+      Encoding::UTF_8
+    end
+  end
+
+  if ''.respond_to?(:encoding)
+    original_encoding = Encoding.default_external
+
+    setup do
+      @file = Tempfile.open('template')
+      @file.puts "stuff"
+      @file.close
+      @template = @file.path
+    end
+
+    teardown do
+      Encoding.default_external = original_encoding
+      Encoding.default_internal = nil
+      @file.delete
+    end
+
+    test "reading from file assumes default external encoding" do
+      Encoding.default_external = 'Big5'
+      inst = MockTemplate.new(@template)
+      assert_equal 'Big5', inst.data.encoding.to_s
+    end
+
+    test "reading from file with a :default_encoding overrides default external" do
+      Encoding.default_external = 'Big5'
+      inst = MockTemplate.new(@template, :default_encoding => 'GBK')
+      assert_equal 'GBK', inst.data.encoding.to_s
+    end
+
+    test "reading from file with default_internal set does no transcoding" do
+      Encoding.default_internal = 'utf-8'
+      Encoding.default_external = 'Big5'
+      inst = MockTemplate.new(@template)
+      assert_equal 'Big5', inst.data.encoding.to_s
+    end
+
+    test "using provided template data verbatim when given as string" do
+      Encoding.default_internal = 'Big5'
+      inst = MockTemplate.new(@template) { "blah".force_encoding('GBK') }
+      assert_equal 'GBK', inst.data.encoding.to_s
+    end
+
+    test "uses the template from the generated source code" do
+      tmpl = "ふが"
+      code = tmpl.inspect.encode('Shift_JIS')
+      inst = DynamicMockTemplate.new(:code => code) { '' }
+      res = inst.render
+      assert_equal 'Shift_JIS', res.encoding.to_s
+      assert_equal tmpl, res.encode(tmpl.encoding)
+    end
+
+    test "uses the magic comment from the generated source code" do
+      tmpl = "ふが"
+      code = ("# coding: Shift_JIS\n" + tmpl.inspect).encode('Shift_JIS')
+      # Set it to an incorrect encoding
+      code.force_encoding('UTF-8')
+
+      inst = DynamicMockTemplate.new(:code => code) { '' }
+      res = inst.render
+      assert_equal 'Shift_JIS', res.encoding.to_s
+      assert_equal tmpl, res.encode(tmpl.encoding)
+    end
+
+    test "uses #default_encoding instead of default_external" do
+      Encoding.default_external = 'Big5'
+      inst = UTF8Template.new(@template)
+      assert_equal 'UTF-8', inst.data.encoding.to_s
+    end
+
+    test "uses #default_encoding instead of current encoding" do
+      tmpl = "".force_encoding('Big5')
+      inst = UTF8Template.new(@template) { tmpl }
+      assert_equal 'UTF-8', inst.data.encoding.to_s
+    end
+
+    test "raises error if the encoding is not valid" do
+      assert_raises(Encoding::InvalidByteSequenceError) do
+        UTF8Template.new(@template) { "\xe4" }
+      end
+    end
+  end
+end

data/vendor/bundle/gems/tilt-1.4.1/test/tilt_test.rb

@@ -0,0 +1,65 @@
+require 'contest'
+require 'tilt'
+
+class TiltTest < Test::Unit::TestCase
+  class MockTemplate
+    attr_reader :args, :block
+    def initialize(*args, &block)
+      @args = args
+      @block = block
+    end
+  end
+
+  test "registering template implementation classes by file extension" do
+    Tilt.register('mock', MockTemplate)
+  end
+
+  test "an extension is registered if explicit handle is found" do
+    Tilt.register('mock', MockTemplate)
+    assert Tilt.registered?('mock')
+  end
+
+  test "registering template classes by symbol file extension" do
+    Tilt.register(:mock, MockTemplate)
+  end
+
+  test "looking up template classes by exact file extension" do
+    Tilt.register('mock', MockTemplate)
+    impl = Tilt['mock']
+    assert_equal MockTemplate, impl
+  end
+
+  test "looking up template classes by implicit file extension" do
+    Tilt.register('mock', MockTemplate)
+    impl = Tilt['.mock']
+    assert_equal MockTemplate, impl
+  end
+
+  test "looking up template classes with multiple file extensions" do
+    Tilt.register('mock', MockTemplate)
+    impl = Tilt['index.html.mock']
+    assert_equal MockTemplate, impl
+  end
+
+  test "looking up template classes by file name" do
+    Tilt.register('mock', MockTemplate)
+    impl = Tilt['templates/test.mock']
+    assert_equal MockTemplate, impl
+  end
+
+  test "looking up non-existant template class" do
+    assert_nil Tilt['none']
+  end
+
+  test "accessing template class mappings at Tilt::mappings" do
+    assert Tilt.respond_to?(:mappings)
+    assert Tilt.mappings.respond_to?(:[])
+  end
+
+  test "creating new template instance with a filename" do
+    Tilt.register('mock', MockTemplate)
+    template = Tilt.new('foo.mock', 1, :key => 'val') { 'Hello World!' }
+    assert_equal ['foo.mock', 1, {:key => 'val'}], template.args
+    assert_equal 'Hello World!', template.block.call
+  end
+end

data/vendor/bundle/gems/tilt-1.4.1/test/tilt_wikiclothtemplate_test.rb

@@ -0,0 +1,32 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'wikicloth'
+
+  class WikiClothTemplateTest < Test::Unit::TestCase
+    test "is registered for '.mediawiki' files" do
+      assert_equal Tilt::WikiClothTemplate, Tilt['test.mediawiki']
+    end
+
+    test "is registered for '.mw' files" do
+      assert_equal Tilt::WikiClothTemplate, Tilt['test.mw']
+    end
+
+    test "is registered for '.wiki' files" do
+      assert_equal Tilt::WikiClothTemplate, Tilt['test.wiki']
+    end
+
+    test "compiles and evaluates the template on #render" do
+      template = Tilt::WikiClothTemplate.new { |t| "= Hello World! =" }
+      assert_match /<h1>.*Hello World!.*<\/h1>/, template.render
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::WikiClothTemplate.new { |t| "= Hello World! =" }
+      3.times { assert_match /<h1>.*Hello World!.*<\/h1>/, template.render }
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::WikiClothTemplate (disabled)"
+end

data/vendor/bundle/gems/tilt-1.4.1/test/tilt_yajltemplate_test.rb

@@ -0,0 +1,101 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'yajl'
+
+  class YajlTemplateTest < Test::Unit::TestCase
+    test "is registered for '.yajl' files" do
+      assert_equal Tilt::YajlTemplate, Tilt['test.yajl']
+    end
+
+    test "compiles and evaluates the template on #render" do
+      template = Tilt::YajlTemplate.new { "json = { :integer => 3, :string => 'hello' }" }
+      output = template.render
+      result = Yajl::Parser.parse(output)
+      expect = {"integer" => 3,"string" => "hello"}
+      assert_equal expect, result
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::YajlTemplate.new { "json = { :integer => 3, :string => 'hello' }" }
+      expect = {"integer" => 3,"string" => "hello"}
+      3.times do
+        output = template.render
+        result = Yajl::Parser.parse(output)
+        assert_equal expect, result
+      end
+    end
+
+    test "evaluating ruby code" do
+      template = Tilt::YajlTemplate.new { "json = { :integer => (3 * 2) }" }
+      assert_equal '{"integer":6}', template.render
+    end
+
+    test "evaluating in an object scope" do
+      template = Tilt::YajlTemplate.new { "json = { :string => 'Hey ' + @name + '!' }" }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      assert_equal '{"string":"Hey Joe!"}', template.render(scope)
+    end
+
+    test "passing locals" do
+      template = Tilt::YajlTemplate.new { "json = { :string => 'Hey ' + name + '!' }" }
+      assert_equal '{"string":"Hey Joe!"}', template.render(Object.new, :name => 'Joe')
+    end
+
+    test "passing a block for yield" do
+      template = Tilt::YajlTemplate.new { "json = { :string => 'Hey ' + yield + '!' }" }
+      assert_equal '{"string":"Hey Joe!"}', template.render { 'Joe' }
+      assert_equal '{"string":"Hey Moe!"}', template.render { 'Moe' }
+    end
+
+    test "template multiline" do
+      template = Tilt::YajlTemplate.new { %Q{
+        json = {
+          :string   => "hello"
+        }
+      } }
+      assert_equal '{"string":"hello"}', template.render
+    end
+
+    test "template can reuse existing json buffer" do
+      template = Tilt::YajlTemplate.new { "json.merge! :string => 'hello'" }
+      assert_equal '{"string":"hello"}', template.render
+    end
+
+    test "template can end with any statement" do
+      template = Tilt::YajlTemplate.new { %Q{
+        json = {
+          :string   => "hello"
+        }
+        four = 2 * 2
+        json[:integer] = four
+        nil
+      } }
+      result = template.render
+      assert( (result == '{"string":"hello","integer":4}') || (result == '{"integer":4,"string":"hello"}') )
+    end
+
+    test "option callback" do
+      options = { :callback => 'foo' }
+      template = Tilt::YajlTemplate.new(nil, options) { "json = { :string => 'hello' }" }
+      assert_equal 'foo({"string":"hello"});', template.render
+    end
+
+    test "option variable" do
+      options = { :variable => 'output' }
+      template = Tilt::YajlTemplate.new(nil, options) { "json = { :string => 'hello' }" }
+      assert_equal 'var output = {"string":"hello"};', template.render
+    end
+
+    test "option callback and variable" do
+      options = { :callback => 'foo', :variable => 'output' }
+      template = Tilt::YajlTemplate.new(nil, options) { "json = { :string => 'hello' }" }
+      assert_equal 'var output = {"string":"hello"}; foo(output);', template.render
+    end
+
+  end
+rescue LoadError
+  warn "Tilt::YajlTemplateTest (disabled)"
+end