torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/tilt-1.3.4/lib/tilt/nokogiri.rb

@@ -1,43 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,246 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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
-