challah 1.0.0.beta2 → 1.0.0.beta3

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

@@ -0,0 +1,214 @@
+require 'tilt/template'
+
+module Tilt
+  # Discount Markdown implementation. See:
+  # http://github.com/rtomayko/rdiscount
+  #
+  # RDiscount is a simple text filter. It does not support +scope+ or
+  # +locals+. The +:smart+ and +:filter_html+ options may be set true
+  # to enable those flags on the underlying RDiscount object.
+  class RDiscountTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    ALIAS = {
+      :escape_html => :filter_html,
+      :smartypants => :smart
+    }
+
+    FLAGS = [:smart, :filter_html, :smartypants, :escape_html]
+
+    def flags
+      FLAGS.select { |flag| options[flag] }.map { |flag| ALIAS[flag] || flag }
+    end
+
+    def self.engine_initialized?
+      defined? ::RDiscount
+    end
+
+    def initialize_engine
+      require_template_library 'rdiscount'
+    end
+
+    def prepare
+      @engine = RDiscount.new(data, *flags)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Upskirt Markdown implementation. See:
+  # https://github.com/tanoku/redcarpet
+  #
+  # Supports both Redcarpet 1.x and 2.x
+  class RedcarpetTemplate < Template
+    def self.engine_initialized?
+      defined? ::Redcarpet
+    end
+
+    def initialize_engine
+      require_template_library 'redcarpet'
+    end
+
+    def prepare
+      klass = [Redcarpet2, Redcarpet1].detect { |e| e.engine_initialized? }
+      @engine = klass.new(file, line, options) { data }
+    end
+
+    def evaluate(scope, locals, &block)
+      @engine.evaluate(scope, locals, &block)
+    end
+
+    def allows_script?
+      false
+    end
+
+    # Compatibility mode for Redcarpet 1.x
+    class Redcarpet1 < RDiscountTemplate
+      self.default_mime_type = 'text/html'
+
+      def self.engine_initialized?
+        defined? ::RedcarpetCompat
+      end
+
+      def prepare
+        @engine = RedcarpetCompat.new(data, *flags)
+        @output = nil
+      end
+    end
+
+    # Future proof mode for Redcarpet 2.x (not yet released)
+    class Redcarpet2 < Template
+      self.default_mime_type = 'text/html'
+
+      def self.engine_initialized?
+        defined? ::Redcarpet::Render and defined? ::Redcarpet::Markdown
+      end
+
+      def generate_renderer
+        renderer = options.delete(:renderer) || ::Redcarpet::Render::HTML
+        return renderer unless options.delete(:smartypants)
+        return renderer if renderer.is_a?(Class) && renderer <= ::Redcarpet::Render::SmartyPants
+
+        if renderer == ::Redcarpet::Render::XHTML
+          ::Redcarpet::Render::SmartyHTML.new(:xhtml => true)
+        elsif renderer == ::Redcarpet::Render::HTML
+          ::Redcarpet::Render::SmartyHTML
+        elsif renderer.is_a? Class
+          Class.new(renderer) { include ::Redcarpet::Render::SmartyPants }
+        else
+          renderer.extend ::Redcarpet::Render::SmartyPants
+        end
+      end
+
+      def prepare
+        # try to support the same aliases
+        RDiscountTemplate::ALIAS.each do |opt, aka|
+          next if options.key? opt or not options.key? aka
+          options[opt] = options.delete(aka)
+        end
+
+        # only raise an exception if someone is trying to enable :escape_html
+        options.delete(:escape_html) unless options[:escape_html]
+
+        @engine = ::Redcarpet::Markdown.new(generate_renderer, options)
+        @output = nil
+      end
+
+      def evaluate(scope, locals, &block)
+        @output ||= @engine.render(data)
+      end
+
+      def allows_script?
+        false
+      end
+    end
+  end
+
+  # BlueCloth Markdown implementation. See:
+  # http://deveiate.org/projects/BlueCloth/
+  class BlueClothTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::BlueCloth
+    end
+
+    def initialize_engine
+      require_template_library 'bluecloth'
+    end
+
+    def prepare
+      @engine = BlueCloth.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Maruku markdown implementation. See:
+  # http://maruku.rubyforge.org/
+  class MarukuTemplate < Template
+    def self.engine_initialized?
+      defined? ::Maruku
+    end
+
+    def initialize_engine
+      require_template_library 'maruku'
+    end
+
+    def prepare
+      @engine = Maruku.new(data, options)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_html
+    end
+
+    def allows_script?
+      false
+    end
+  end
+
+  # Kramdown Markdown implementation. See:
+  # http://kramdown.rubyforge.org/
+  class KramdownTemplate < Template
+    DUMB_QUOTES = [39, 39, 34, 34]
+
+    def self.engine_initialized?
+      defined? ::Kramdown
+    end
+
+    def initialize_engine
+      require_template_library 'kramdown'
+    end
+
+    def prepare
+      options[:smart_quotes] = DUMB_QUOTES unless options[:smartypants]
+      @engine = Kramdown::Document.new(data, options)
+      @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/nokogiri.rb

@@ -0,0 +1,43 @@
+require 'tilt/template'
+
+module Tilt
+  # Nokogiri template implementation. See:
+  # http://nokogiri.org/
+  class NokogiriTemplate < Template
+    DOCUMENT_HEADER = /^<\?xml version=\"1\.0\"\?>\n?/
+    self.default_mime_type = 'text/xml'
+
+    def self.engine_initialized?
+      defined? ::Nokogiri
+    end
+
+    def initialize_engine
+      require_template_library 'nokogiri'
+    end
+
+    def prepare; end
+
+    def evaluate(scope, locals)
+      if data.respond_to?(:to_str)
+        wrapper = proc { yield.sub(DOCUMENT_HEADER, "") } if block_given?
+        super(scope, locals, &wrapper)
+      else
+        ::Nokogiri::XML::Builder.new.tap(&data).to_xml
+      end
+    end
+
+    def precompiled_preamble(locals)
+      return super if locals.include? :xml
+      "xml = ::Nokogiri::XML::Builder.new { |xml| }\n#{super}"
+    end
+
+    def precompiled_postamble(locals)
+      "xml.to_xml"
+    end
+
+    def precompiled_template(locals)
+      data.to_str
+    end
+  end
+end
+

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

@@ -0,0 +1,20 @@
+require 'tilt/template'
+
+
+module Tilt
+  # Raw text (no template functionality).
+  class PlainTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      true
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= data
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'tilt/template'
+
+module Tilt
+  # Radius Template
+  # http://github.com/jlong/radius/
+  class RadiusTemplate < Template
+    def self.engine_initialized?
+      defined? ::Radius
+    end
+
+    def self.context_class
+      @context_class ||= Class.new(Radius::Context) do
+        attr_accessor :tilt_scope
+
+        def tag_missing(name, attributes)
+          tilt_scope.__send__(name)
+        end
+
+        def dup
+          i = super
+          i.tilt_scope = tilt_scope
+          i
+        end
+      end
+    end
+
+    def initialize_engine
+      require_template_library 'radius'
+    end
+
+    def prepare
+    end
+
+    def evaluate(scope, locals, &block)
+      context = self.class.context_class.new
+      context.tilt_scope = scope
+      context.define_tag("yield") do
+        block.call
+      end
+      locals.each do |tag, value|
+        context.define_tag(tag) do
+          value
+        end
+      end
+
+      options = {:tag_prefix => 'r'}.merge(@options)
+      parser = Radius::Parser.new(context, options)
+      parser.parse(data)
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'tilt/template'
+
+module Tilt
+  # RDoc template. See:
+  # http://rdoc.rubyforge.org/
+  #
+  # It's suggested that your program `require 'rdoc/markup'` and
+  # `require 'rdoc/markup/to_html'` at load time when using this template
+  # engine in a threaded environment.
+  class RDocTemplate < Template
+    self.default_mime_type = 'text/html'
+
+    def self.engine_initialized?
+      defined? ::RDoc::Markup::ToHtml
+    end
+
+    def initialize_engine
+      require_template_library 'rdoc'
+      require_template_library 'rdoc/markup'
+      require_template_library 'rdoc/markup/to_html'
+    end
+
+    def markup
+      begin
+        # RDoc 4.0
+        require 'rdoc/options'
+        RDoc::Markup::ToHtml.new(RDoc::Options.new, nil)
+      rescue ArgumentError
+        # RDoc < 4.0
+        RDoc::Markup::ToHtml.new
+      end
+    end
+
+    def prepare
+      @engine = markup.convert(data)
+      @output = nil
+    end
+
+    def evaluate(scope, locals, &block)
+      @output ||= @engine.to_s
+    end
+
+    def allows_script?
+      false
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require 'tilt/template'
+
+module Tilt
+  # The template source is evaluated as a Ruby string. The #{} interpolation
+  # syntax can be used to generated dynamic output.
+  class StringTemplate < Template
+    def prepare
+      hash = "TILT#{data.hash.abs}"
+      @code = "<<#{hash}.chomp\n#{data}\n#{hash}"
+    end
+
+    def precompiled_template(locals)
+      @code
+    end
+
+    def precompiled(locals)
+      source, offset = super
+      [source, offset + 1]
+    end
+  end
+end

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

@@ -0,0 +1,292 @@
+module Tilt
+  TOPOBJECT = Object.superclass || Object
+
+  # Base class for template implementations. Subclasses must implement
+  # the #prepare method and one of the #evaluate or #precompiled_template
+  # methods.
+  class Template
+    # Template source; loaded from a file or given directly.
+    attr_reader :data
+
+    # The name of the file where the template data was loaded from.
+    attr_reader :file
+
+    # The line number in #file where template data was loaded from.
+    attr_reader :line
+
+    # A Hash of template engine specific options. This is passed directly
+    # to the underlying engine and is not used by the generic template
+    # interface.
+    attr_reader :options
+
+    # Used to determine if this class's initialize_engine method has
+    # been called yet.
+    @engine_initialized = false
+    class << self
+      attr_accessor :engine_initialized
+      alias engine_initialized? engine_initialized
+
+      attr_accessor :default_mime_type
+    end
+
+    # Create a new template with the file, line, and options specified. By
+    # default, template data is read from the file. When a block is given,
+    # it should read template data and return as a String. When file is nil,
+    # a block is required.
+    #
+    # All arguments are optional.
+    def initialize(file=nil, line=1, options={}, &block)
+      @file, @line, @options = nil, 1, {}
+
+      [options, line, file].compact.each do |arg|
+        case
+        when arg.respond_to?(:to_str)  ; @file = arg.to_str
+        when arg.respond_to?(:to_int)  ; @line = arg.to_int
+        when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
+        when arg.respond_to?(:path)    ; @file = arg.path
+        else raise TypeError
+        end
+      end
+
+      raise ArgumentError, "file or block required" if (@file || block).nil?
+
+      # call the initialize_engine method if this is the very first time
+      # an instance of this class has been created.
+      if !self.class.engine_initialized?
+        initialize_engine
+        self.class.engine_initialized = true
+      end
+
+      # used to hold compiled template methods
+      @compiled_method = {}
+
+      # used on 1.9 to set the encoding if it is not set elsewhere (like a magic comment)
+      # currently only used if template compiles to ruby
+      @default_encoding = @options.delete :default_encoding
+
+      # load template data and prepare (uses binread to avoid encoding issues)
+      @reader = block || lambda { |t| read_template_file }
+      @data = @reader.call(self)
+
+      if @data.respond_to?(:force_encoding)
+        @data.force_encoding(default_encoding) if default_encoding
+
+        if !@data.valid_encoding?
+          raise Encoding::InvalidByteSequenceError, "#{eval_file} is not valid #{@data.encoding}"
+        end
+      end
+
+      prepare
+    end
+
+    # The encoding of the source data. Defaults to the
+    # default_encoding-option if present. You may override this method
+    # in your template class if you have a better hint of the data's
+    # encoding.
+    def default_encoding
+      @default_encoding
+    end
+
+    def read_template_file
+      data = File.open(file, 'rb') { |io| io.read }
+      if data.respond_to?(:force_encoding)
+        # Set it to the default external (without verifying)
+        data.force_encoding(Encoding.default_external) if Encoding.default_external
+      end
+      data
+    end
+
+    # Render the template in the given scope with the locals specified. If a
+    # block is given, it is typically available within the template via
+    # +yield+.
+    def render(scope=Object.new, locals={}, &block)
+      evaluate scope, locals || {}, &block
+    end
+
+    # The basename of the template file.
+    def basename(suffix='')
+      File.basename(file, suffix) if file
+    end
+
+    # The template file's basename with all extensions chomped off.
+    def name
+      basename.split('.', 2).first if basename
+    end
+
+    # The filename used in backtraces to describe the template.
+    def eval_file
+      file || '(__TEMPLATE__)'
+    end
+
+    # Whether or not this template engine allows executing Ruby script
+    # within the template. If this is false, +scope+ and +locals+ will
+    # generally not be used, nor will the provided block be avaiable 
+    # via +yield+.
+    # This should be overridden by template subclasses.
+    def allows_script?
+      true
+    end
+
+  protected
+    # Called once and only once for each template subclass the first time
+    # the template class is initialized. This should be used to require the
+    # underlying template library and perform any initial setup.
+    def initialize_engine
+    end
+
+    # Like Kernel#require but issues a warning urging a manual require when
+    # running under a threaded environment.
+    def require_template_library(name)
+      if Thread.list.size > 1
+        warn "WARN: tilt autoloading '#{name}' in a non thread-safe way; " +
+             "explicit require '#{name}' suggested."
+      end
+      require name
+    end
+
+    # Do whatever preparation is necessary to setup the underlying template
+    # engine. Called immediately after template data is loaded. Instance
+    # variables set in this method are available when #evaluate is called.
+    #
+    # Subclasses must provide an implementation of this method.
+    def prepare
+      if respond_to?(:compile!)
+        # backward compat with tilt < 0.6; just in case
+        warn 'Tilt::Template#compile! is deprecated; implement #prepare instead.'
+        compile!
+      else
+        raise NotImplementedError
+      end
+    end
+
+    # Execute the compiled template and return the result string. Template
+    # evaluation is guaranteed to be performed in the scope object with the
+    # locals specified and with support for yielding to the block.
+    #
+    # This method is only used by source generating templates. Subclasses that
+    # override render() may not support all features.
+    def evaluate(scope, locals, &block)
+      method = compiled_method(locals.keys)
+      method.bind(scope).call(locals, &block)
+    end
+
+    # Generates all template source by combining the preamble, template, and
+    # postamble and returns a two-tuple of the form: [source, offset], where
+    # source is the string containing (Ruby) source code for the template and
+    # offset is the integer line offset where line reporting should begin.
+    #
+    # Template subclasses may override this method when they need complete
+    # control over source generation or want to adjust the default line
+    # offset. In most cases, overriding the #precompiled_template method is
+    # easier and more appropriate.
+    def precompiled(locals)
+      preamble = precompiled_preamble(locals)
+      template = precompiled_template(locals)
+      postamble = precompiled_postamble(locals)
+      source = ''
+
+      # Ensure that our generated source code has the same encoding as the
+      # the source code generated by the template engine.
+      if source.respond_to?(:force_encoding)
+        template_encoding = extract_encoding(template)
+
+        source.force_encoding(template_encoding)
+        template.force_encoding(template_encoding)
+      end
+
+      # https://github.com/rtomayko/tilt/issues/193
+      warn "precompiled_preamble should return String (not Array)" if preamble.is_a?(Array)
+      warn "precompiled_postamble should return String (not Array)" if postamble.is_a?(Array)
+      source << [preamble, template, postamble].join("\n")
+
+      [source, preamble.count("\n")+1]
+    end
+
+    # A string containing the (Ruby) source code for the template. The
+    # default Template#evaluate implementation requires either this
+    # method or the #precompiled method be overridden. When defined,
+    # the base Template guarantees correct file/line handling, locals
+    # support, custom scopes, proper encoding, and support for template
+    # compilation.
+    def precompiled_template(locals)
+      raise NotImplementedError
+    end
+
+    # Generates preamble code for initializing template state, and performing
+    # locals assignment. The default implementation performs locals
+    # assignment only. Lines included in the preamble are subtracted from the
+    # source line offset, so adding code to the preamble does not effect line
+    # reporting in Kernel::caller and backtraces.
+    def precompiled_preamble(locals)
+      locals.map do |k,v|
+        if k.to_s =~ /\A[a-z_][a-zA-Z_0-9]*\z/
+          "#{k} = locals[#{k.inspect}]"
+        else
+          raise "invalid locals key: #{k.inspect} (keys must be variable names)"
+        end
+      end.join("\n")
+    end
+
+    # Generates postamble code for the precompiled template source. The
+    # string returned from this method is appended to the precompiled
+    # template source.
+    def precompiled_postamble(locals)
+      ''
+    end
+
+    # The compiled method for the locals keys provided.
+    def compiled_method(locals_keys)
+      @compiled_method[locals_keys] ||=
+        compile_template_method(locals_keys)
+    end
+
+  private
+    def compile_template_method(locals)
+      source, offset = precompiled(locals)
+      method_name = "__tilt_#{Thread.current.object_id.abs}"
+      method_source = ""
+
+      if method_source.respond_to?(:force_encoding)
+        method_source.force_encoding(source.encoding) 
+      end
+
+      method_source << <<-RUBY
+        TOPOBJECT.class_eval do
+          def #{method_name}(locals)
+            Thread.current[:tilt_vars] = [self, locals]
+            class << self
+              this, locals = Thread.current[:tilt_vars]
+              this.instance_eval do
+      RUBY
+      offset += method_source.count("\n")
+      method_source << source
+      method_source << "\nend;end;end;end"
+      Object.class_eval method_source, eval_file, line - offset
+      unbind_compiled_method(method_name)
+    end
+
+    def unbind_compiled_method(method_name)
+      method = TOPOBJECT.instance_method(method_name)
+      TOPOBJECT.class_eval { remove_method(method_name) }
+      method
+    end
+
+    def extract_encoding(script)
+      extract_magic_comment(script) || script.encoding
+    end
+
+    def extract_magic_comment(script)
+      binary script do
+        script[/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/n, 1]
+      end
+    end
+
+    def binary(string)
+      original_encoding = string.encoding
+      string.force_encoding(Encoding::BINARY)
+      yield
+    ensure
+      string.force_encoding(original_encoding)
+    end
+  end
+end