challah 1.0.0.beta2 → 1.0.0.beta3

data/vendor/bundle/gems/tilt-1.4.1/lib/tilt/textile.rb

@@ -0,0 +1,30 @@
+require 'tilt/template'
+
+module Tilt
+  # RedCloth implementation. See:
+  # http://redcloth.org/
+  class RedClothTemplate < Template
+    def self.engine_initialized?
+      defined? ::RedCloth
+    end
+
+    def initialize_engine
+      require_template_library 'redcloth'
+    end
+
+    def prepare
+      @engine = RedCloth.new(data)
+      options.each {|k, v| @engine.send("#{k}=", v) if @engine.respond_to? "#{k}="}
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end
+

data/vendor/bundle/gems/tilt-1.4.1/lib/tilt/wiki.rb

@@ -0,0 +1,58 @@
+require 'tilt/template'
+
+module Tilt
+  # Creole implementation. See:
+  # http://www.wikicreole.org/
+  class CreoleTemplate < Template
+    def self.engine_initialized?
+      defined? ::Creole
+    end
+
+    def initialize_engine
+      require_template_library 'creole'
+    end
+
+    def prepare
+      opts = {}
+      [:allowed_schemes, :extensions, :no_escape].each do |k|
+        opts[k] = options[k] if options[k]
+      end
+      @engine = Creole::Parser.new(data, opts)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # WikiCloth implementation. See:
+  # http://redcloth.org/
+  class WikiClothTemplate < Template
+    def self.engine_initialized?
+      defined? ::WikiCloth::Parser
+    end
+
+    def initialize_engine
+      require_template_library 'wikicloth'
+    end
+
+    def prepare
+      @parser = options.delete(:parser) || WikiCloth::Parser
+      @engine = @parser.new options.merge(:data => data)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

data/vendor/bundle/gems/tilt-1.4.1/lib/tilt/yajl.rb

@@ -0,0 +1,94 @@
+require 'tilt/template'
+
+module Tilt
+
+  # Yajl Template implementation
+  #
+  # Yajl is a fast JSON parsing and encoding library for Ruby
+  # See https://github.com/brianmario/yajl-ruby
+  #
+  # The template source is evaluated as a Ruby string,
+  # and the result is converted #to_json.
+  #
+  # == Example
+  #
+  #    # This is a template example.
+  #    # The template can contain any Ruby statement.
+  #    tpl <<-EOS
+  #      @counter = 0
+  #
+  #      # The json variable represents the buffer
+  #      # and holds the data to be serialized into json.
+  #      # It defaults to an empty hash, but you can override it at any time.
+  #      json = {
+  #        :"user#{@counter += 1}" => { :name => "Joshua Peek", :id => @counter },
+  #        :"user#{@counter += 1}" => { :name => "Ryan Tomayko", :id => @counter },
+  #        :"user#{@counter += 1}" => { :name => "Simone Carletti", :id => @counter },
+  #      }
+  #
+  #      # Since the json variable is a Hash,
+  #      # you can use conditional statements or any other Ruby statement
+  #      # to populate it.
+  #      json[:"user#{@counter += 1}"] = { :name => "Unknown" } if 1 == 2
+  #
+  #      # The last line doesn't affect the returned value.
+  #      nil
+  #    EOS
+  #
+  #    template = Tilt::YajlTemplate.new { tpl }
+  #    template.render(self)
+  #
+  class YajlTemplate < Template
+
+    self.default_mime_type = 'application/json'
+
+    def self.engine_initialized?
+      defined? ::Yajl
+    end
+
+    def initialize_engine
+      require_template_library 'yajl'
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      decorate super(scope, locals, &block)
+    end
+
+    def precompiled_preamble(locals)
+      return super if locals.include? :json
+      "json = {}\n#{super}"
+    end
+
+    def precompiled_postamble(locals)
+      "Yajl::Encoder.new.encode(json)"
+    end
+
+    def precompiled_template(locals)
+      data.to_str
+    end
+
+
+    # Decorates the +json+ input according to given +options+.
+    #
+    # json    - The json String to decorate.
+    # options - The option Hash to customize the behavior.
+    #
+    # Returns the decorated String.
+    def decorate(json)
+      callback, variable = options[:callback], options[:variable]
+      if callback && variable
+        "var #{variable} = #{json}; #{callback}(#{variable});"
+      elsif variable
+        "var #{variable} = #{json};"
+      elsif callback
+        "#{callback}(#{json});"
+      else
+        json
+      end
+    end
+  end
+
+end

data/vendor/bundle/gems/tilt-1.4.1/lib/tilt.rb

@@ -0,0 +1,204 @@
+module Tilt
+  VERSION = '1.4.1'
+
+  @preferred_mappings = Hash.new
+  @template_mappings = Hash.new { |h, k| h[k] = [] }
+
+  # Hash of template path pattern => template implementation class mappings.
+  def self.mappings
+    @template_mappings
+  end
+
+  def self.normalize(ext)
+    ext.to_s.downcase.sub(/^\./, '')
+  end
+
+  # Register a template implementation by file extension.
+  def self.register(template_class, *extensions)
+    if template_class.respond_to?(:to_str)
+      # Support register(ext, template_class) too
+      extensions, template_class = [template_class], extensions[0]
+    end
+
+    extensions.each do |ext|
+      ext = normalize(ext)
+      mappings[ext].unshift(template_class).uniq!
+    end
+  end
+
+  # Makes a template class preferred for the given file extensions. If you
+  # don't provide any extensions, it will be preferred for all its already
+  # registered extensions:
+  #
+  #   # Prefer RDiscount for its registered file extensions:
+  #   Tilt.prefer(Tilt::RDiscountTemplate)
+  #
+  #   # Prefer RDiscount only for the .md extensions:
+  #   Tilt.prefer(Tilt::RDiscountTemplate, '.md')
+  def self.prefer(template_class, *extensions)
+    if extensions.empty?
+      mappings.each do |ext, klasses|
+        @preferred_mappings[ext] = template_class if klasses.include? template_class
+      end
+    else
+      extensions.each do |ext|
+        ext = normalize(ext)
+        register(template_class, ext)
+        @preferred_mappings[ext] = template_class
+      end
+    end
+  end
+
+  # Returns true when a template exists on an exact match of the provided file extension
+  def self.registered?(ext)
+    mappings.key?(ext.downcase) && !mappings[ext.downcase].empty?
+  end
+
+  # Create a new template for the given file using the file's extension
+  # to determine the the template mapping.
+  def self.new(file, line=nil, options={}, &block)
+    if template_class = self[file]
+      template_class.new(file, line, options, &block)
+    else
+      fail "No template engine registered for #{File.basename(file)}"
+    end
+  end
+
+  # Lookup a template class for the given filename or file
+  # extension. Return nil when no implementation is found.
+  def self.[](file)
+    pattern = file.to_s.downcase
+    until pattern.empty? || registered?(pattern)
+      pattern = File.basename(pattern)
+      pattern.sub!(/^[^.]*\.?/, '')
+    end
+
+    # Try to find a preferred engine.
+    preferred_klass = @preferred_mappings[pattern]
+    return preferred_klass if preferred_klass
+
+    # Fall back to the general list of mappings.
+    klasses = @template_mappings[pattern]
+
+    # Try to find an engine which is already loaded.
+    template = klasses.detect do |klass|
+      if klass.respond_to?(:engine_initialized?)
+        klass.engine_initialized?
+      end
+    end
+
+    return template if template
+
+    # Try each of the classes until one succeeds. If all of them fails,
+    # we'll raise the error of the first class.
+    first_failure = nil
+
+    klasses.each do |klass|
+      begin
+        klass.new { '' }
+      rescue Exception => ex
+        first_failure ||= ex
+        next
+      else
+        return klass
+      end
+    end
+
+    raise first_failure if first_failure
+  end
+
+  # Deprecated module.
+  module CompileSite
+  end
+
+  # Extremely simple template cache implementation. Calling applications
+  # create a Tilt::Cache instance and use #fetch with any set of hashable
+  # arguments (such as those to Tilt.new):
+  #   cache = Tilt::Cache.new
+  #   cache.fetch(path, line, options) { Tilt.new(path, line, options) }
+  #
+  # Subsequent invocations return the already loaded template object.
+  class Cache
+    def initialize
+      @cache = {}
+    end
+
+    def fetch(*key)
+      @cache[key] ||= yield
+    end
+
+    def clear
+      @cache = {}
+    end
+  end
+
+
+  # Template Implementations ================================================
+
+  require 'tilt/string'
+  register StringTemplate, 'str'
+
+  require 'tilt/erb'
+  register ERBTemplate,    'erb', 'rhtml'
+  register ErubisTemplate, 'erb', 'rhtml', 'erubis'
+
+  require 'tilt/etanni'
+  register EtanniTemplate, 'etn', 'etanni'
+
+  require 'tilt/haml'
+  register HamlTemplate,   'haml'
+
+  require 'tilt/css'
+  register SassTemplate, 'sass'
+  register ScssTemplate, 'scss'
+  register LessTemplate, 'less'
+
+  require 'tilt/csv'
+  register CSVTemplate, 'rcsv'
+
+  require 'tilt/coffee'
+  register CoffeeScriptTemplate, 'coffee'
+
+  require 'tilt/nokogiri'
+  register NokogiriTemplate, 'nokogiri'
+
+  require 'tilt/builder'
+  register BuilderTemplate,  'builder'
+
+  require 'tilt/markaby'
+  register MarkabyTemplate,  'mab'
+
+  require 'tilt/liquid'
+  register LiquidTemplate, 'liquid'
+
+  require 'tilt/radius'
+  register RadiusTemplate, 'radius'
+
+  require 'tilt/markdown'
+  register MarukuTemplate,    'markdown', 'mkd', 'md'
+  register KramdownTemplate,  'markdown', 'mkd', 'md'
+  register BlueClothTemplate, 'markdown', 'mkd', 'md'
+  register RDiscountTemplate, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate::Redcarpet1, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate::Redcarpet2, 'markdown', 'mkd', 'md'
+  register RedcarpetTemplate, 'markdown', 'mkd', 'md'
+
+  require 'tilt/textile'
+  register RedClothTemplate, 'textile'
+
+  require 'tilt/rdoc'
+  register RDocTemplate, 'rdoc'
+
+  require 'tilt/wiki'
+  register CreoleTemplate,    'wiki', 'creole'
+  register WikiClothTemplate, 'wiki', 'mediawiki', 'mw'
+
+  require 'tilt/yajl'
+  register YajlTemplate, 'yajl'
+
+  require 'tilt/asciidoc'
+  register AsciidoctorTemplate, 'ad', 'adoc', 'asciidoc'
+
+  require 'tilt/plain'
+  register PlainTemplate, 'html'
+end

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

@@ -0,0 +1,68 @@
+require "test/unit"
+
+# Test::Unit loads a default test if the suite is empty, whose purpose is to
+# fail. Since having empty contexts is a common practice, we decided to
+# overwrite TestSuite#empty? in order to allow them. Having a failure when no
+# tests have been defined seems counter-intuitive.
+class Test::Unit::TestSuite
+  def empty?
+    false
+  end
+end
+
+# Contest adds +teardown+, +test+ and +context+ as class methods, and the
+# instance methods +setup+ and +teardown+ now iterate on the corresponding
+# blocks. Note that all setup and teardown blocks must be defined with the
+# block syntax. Adding setup or teardown instance methods defeats the purpose
+# of this library.
+class Test::Unit::TestCase
+  def self.setup(&block)
+    define_method :setup do
+      super(&block)
+      instance_eval(&block)
+    end
+  end
+
+  def self.teardown(&block)
+    define_method :teardown do
+      instance_eval(&block)
+      super(&block)
+    end
+  end
+
+  def self.context(name, &block)
+    subclass = Class.new(self)
+    remove_tests(subclass)
+    subclass.class_eval(&block) if block_given?
+    const_set(context_name(name), subclass)
+  end
+
+  def self.test(name, &block)
+    define_method(test_name(name), &block)
+  end
+
+  class << self
+    alias_method :should, :test
+    alias_method :describe, :context
+  end
+
+private
+
+  def self.context_name(name)
+    "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}".to_sym
+  end
+
+  def self.test_name(name)
+    "test_#{sanitize_name(name).gsub(/\s+/,'_')}".to_sym
+  end
+
+  def self.sanitize_name(name)
+    name.gsub(/\W+/, ' ').strip
+  end
+
+  def self.remove_tests(subclass)
+    subclass.public_instance_methods.grep(/^test_/).each do |meth|
+      subclass.send(:undef_method, meth.to_sym)
+    end
+  end
+end

data/vendor/bundle/gems/tilt-1.4.1/test/markaby/locals.mab

@@ -0,0 +1 @@
+li foo

data/vendor/bundle/gems/tilt-1.4.1/test/markaby/markaby.mab

@@ -0,0 +1 @@
+text "hello from markaby!"

data/vendor/bundle/gems/tilt-1.4.1/test/markaby/markaby_other_static.mab

@@ -0,0 +1 @@
+text "_why?"

data/vendor/bundle/gems/tilt-1.4.1/test/markaby/render_twice.mab

@@ -0,0 +1 @@
+text "foo"

data/vendor/bundle/gems/tilt-1.4.1/test/markaby/scope.mab

@@ -0,0 +1 @@
+li foo

data/vendor/bundle/gems/tilt-1.4.1/test/markaby/yielding.mab

@@ -0,0 +1,2 @@
+text("Hey ")
+yield

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

@@ -0,0 +1,44 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'asciidoctor'
+
+  class AsciidoctorTemplateTest < Test::Unit::TestCase
+    HTML5_OUTPUT = "<div class=\"sect1\"><h2 id=\"_hello_world\">Hello World!</h2><div class=\"sectionbody\"></div></div>"
+    DOCBOOK_OUTPUT = "<section id=\"_hello_world\"><title>Hello World!</title></section>"
+
+    def strip_space(str)
+      str.gsub(/>\s+</, '><').strip
+    end
+
+    test "registered for '.ad' files" do
+      assert Tilt.mappings['ad'].include?(Tilt::AsciidoctorTemplate)
+    end
+
+    test "registered for '.adoc' files" do
+      assert Tilt.mappings['adoc'].include?(Tilt::AsciidoctorTemplate)
+    end
+
+    test "registered for '.asciidoc' files" do
+      assert Tilt.mappings['asciidoc'].include?(Tilt::AsciidoctorTemplate)
+    end
+
+    test "preparing and evaluating html5 templates on #render" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'html5'}) { |t| "== Hello World!" } 
+      assert_equal HTML5_OUTPUT, strip_space(template.render)
+    end
+
+    test "preparing and evaluating docbook templates on #render" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'docbook'}) { |t| "== Hello World!" } 
+      assert_equal DOCBOOK_OUTPUT, strip_space(template.render)
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::AsciidoctorTemplate.new(:attributes => {"backend" => 'html5'}) { |t| "== Hello World!" } 
+      3.times { assert_equal HTML5_OUTPUT, strip_space(template.render) }
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::AsciidoctorTemplate (disabled)"
+end

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

@@ -0,0 +1,45 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'bluecloth'
+
+  class BlueClothTemplateTest < Test::Unit::TestCase
+    test "registered for '.md' files" do
+      assert Tilt.mappings['md'].include?(Tilt::BlueClothTemplate)
+    end
+
+    test "registered for '.mkd' files" do
+      assert Tilt.mappings['mkd'].include?(Tilt::BlueClothTemplate)
+    end
+
+    test "registered for '.markdown' files" do
+      assert Tilt.mappings['markdown'].include?(Tilt::BlueClothTemplate)
+    end
+
+    test "preparing and evaluating templates on #render" do
+      template = Tilt::BlueClothTemplate.new { |t| "# Hello World!" }
+      assert_equal "<h1>Hello World!</h1>", template.render
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::BlueClothTemplate.new { |t| "# Hello World!" }
+      3.times { assert_equal "<h1>Hello World!</h1>", template.render }
+    end
+
+    test "smartypants when :smart is set" do
+      template = Tilt::BlueClothTemplate.new(:smartypants => true) { |t|
+        "OKAY -- 'Smarty Pants'" }
+      assert_equal "<p>OKAY &mdash; &lsquo;Smarty Pants&rsquo;</p>",
+        template.render
+    end
+
+    test "stripping HTML when :filter_html is set" do
+      template = Tilt::BlueClothTemplate.new(:escape_html => true) { |t|
+        "HELLO <blink>WORLD</blink>" }
+      assert_equal "<p>HELLO &lt;blink>WORLD&lt;/blink></p>", template.render
+    end
+  end
+rescue LoadError => boom
+  warn "Tilt::BlueClothTemplate (disabled)"
+end

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

@@ -0,0 +1,59 @@
+require 'contest'
+require 'tilt'
+
+begin
+  require 'builder'
+  class BuilderTemplateTest < Test::Unit::TestCase
+    test "registered for '.builder' files" do
+      assert_equal Tilt::BuilderTemplate, Tilt['test.builder']
+      assert_equal Tilt::BuilderTemplate, Tilt['test.xml.builder']
+    end
+
+    test "preparing and evaluating the template on #render" do
+      template = Tilt::BuilderTemplate.new { |t| "xml.em 'Hello World!'" }
+      assert_equal "<em>Hello World!</em>\n", template.render
+    end
+
+    test "can be rendered more than once" do
+      template = Tilt::BuilderTemplate.new { |t| "xml.em 'Hello World!'" }
+      3.times { assert_equal "<em>Hello World!</em>\n", template.render }
+    end
+
+    test "passing locals" do
+      template = Tilt::BuilderTemplate.new { "xml.em('Hey ' + name + '!')" }
+      assert_equal "<em>Hey Joe!</em>\n", template.render(Object.new, :name => 'Joe')
+    end
+
+    test "evaluating in an object scope" do
+      template = Tilt::BuilderTemplate.new { "xml.em('Hey ' + @name + '!')" }
+      scope = Object.new
+      scope.instance_variable_set :@name, 'Joe'
+      assert_equal "<em>Hey Joe!</em>\n", template.render(scope)
+    end
+
+    test "passing a block for yield" do
+      template = Tilt::BuilderTemplate.new { "xml.em('Hey ' + yield + '!')" }
+      3.times { assert_equal "<em>Hey Joe!</em>\n", template.render { 'Joe' }}
+    end
+
+    test "block style templates" do
+      template =
+        Tilt::BuilderTemplate.new do |t|
+          lambda { |xml| xml.em('Hey Joe!') }
+        end
+      assert_equal "<em>Hey Joe!</em>\n", template.render
+    end
+
+    test "allows nesting raw XML" do
+      subtemplate = Tilt::BuilderTemplate.new { "xml.em 'Hello World!'" }
+      template = Tilt::BuilderTemplate.new { "xml.strong { xml << yield }" }
+      3.times do
+        options = { :xml => Builder::XmlMarkup.new }
+        assert_equal "<strong>\n<em>Hello World!</em>\n</strong>\n",
+          template.render(options) { subtemplate.render(options) }
+      end
+    end
+  end
+rescue LoadError
+  warn "Tilt::BuilderTemplate (disabled)"
+end

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

@@ -0,0 +1,32 @@
+require 'contest'
+require 'tilt'
+
+class TiltCacheTest < Test::Unit::TestCase
+  setup { @cache = Tilt::Cache.new }
+
+  test "caching with single simple argument to #fetch" do
+    template = nil
+    result = @cache.fetch('hello') { template = Tilt::StringTemplate.new {''} }
+    assert_same template, result
+    result = @cache.fetch('hello') { fail 'should be cached' }
+    assert_same template, result
+  end
+
+  test "caching with multiple complex arguments to #fetch" do
+    template = nil
+    result = @cache.fetch('hello', {:foo => 'bar', :baz => 'bizzle'}) { template = Tilt::StringTemplate.new {''} }
+    assert_same template, result
+    result = @cache.fetch('hello', {:foo => 'bar', :baz => 'bizzle'}) { fail 'should be cached' }
+    assert_same template, result
+  end
+
+  test "clearing the cache with #clear" do
+    template, other = nil
+    result = @cache.fetch('hello') { template = Tilt::StringTemplate.new {''} }
+    assert_same template, result
+
+    @cache.clear
+    result = @cache.fetch('hello') { other = Tilt::StringTemplate.new {''} }
+    assert_same other, result
+  end
+end