torquebox-console 0.2.3 → 0.2.4

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/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/ruby/1.8/gems/tilt-1.3.4/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/ruby/1.8/gems/tilt-1.3.4/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/ruby/1.8/gems/tilt-1.3.4/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/ruby/1.8/gems/tilt-1.3.4/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/ruby/1.8/gems/tilt-1.3.4/lib/tilt/template.rb

@@ -0,0 +1,246 @@
+module Tilt
+  TOPOBJECT = defined?(BasicObject) ? BasicObject : 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?(:path)    ; @file = arg.path
+        when arg.respond_to?(:to_int)  ; @line = arg.to_int
+        when arg.respond_to?(:to_hash) ; @options = arg.to_hash.dup
+        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| File.respond_to?(:binread) ? File.binread(@file) : File.read(@file) }
+      @data = @reader.call(self)
+      prepare
+    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)
+      magic_comment = extract_magic_comment(template)
+      if magic_comment
+        # Magic comment e.g. "# coding: utf-8" has to be in the first line.
+        # So we copy the magic comment to the first line.
+        preamble = magic_comment + "\n" + preamble
+      end
+      parts = [
+        preamble,
+        template,
+        precompiled_postamble(locals)
+      ]
+      [parts.join("\n"), 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, and support for template compilation when the scope object
+    # allows it.
+    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]\w*\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 = <<-RUBY
+        #{extract_magic_comment source}
+        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_magic_comment(script)
+      comment = script.slice(/\A[ \t]*\#.*coding\s*[=:]\s*([[:alnum:]\-_]+).*$/)
+      if comment && !%w[ascii-8bit binary].include?($1.downcase)
+        comment
+      elsif @default_encoding
+        "# coding: #{@default_encoding}"
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/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
+