torquebox-console 0.2.5 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/etag.rb

@@ -1,64 +0,0 @@
-require 'digest/md5'
-
-module Rack
-  # Automatically sets the ETag header on all String bodies.
-  #
-  # The ETag header is skipped if ETag or Last-Modified headers are sent or if
-  # a sendfile body (body.responds_to :to_path) is given (since such cases
-  # should be handled by apache/nginx).
-  #
-  # On initialization, you can pass two parameters: a Cache-Control directive
-  # used when Etag is absent and a directive when it is present. The first
-  # defaults to nil, while the second defaults to "max-age=0, private, must-revalidate"
-  class ETag
-    DEFAULT_CACHE_CONTROL = "max-age=0, private, must-revalidate".freeze
-
-    def initialize(app, no_cache_control = nil, cache_control = DEFAULT_CACHE_CONTROL)
-      @app = app
-      @cache_control = cache_control
-      @no_cache_control = no_cache_control
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-
-      if etag_status?(status) && etag_body?(body) && !skip_caching?(headers)
-        digest, body = digest_body(body)
-        headers['ETag'] = %("#{digest}") if digest
-      end
-
-      unless headers['Cache-Control']
-        if digest
-          headers['Cache-Control'] = @cache_control if @cache_control
-        else
-          headers['Cache-Control'] = @no_cache_control if @no_cache_control
-        end
-      end
-
-      [status, headers, body]
-    end
-
-    private
-
-      def etag_status?(status)
-        status == 200 || status == 201
-      end
-
-      def etag_body?(body)
-        !body.respond_to?(:to_path)
-      end
-
-      def skip_caching?(headers)
-        (headers['Cache-Control'] && headers['Cache-Control'].include?('no-cache')) ||
-          headers.key?('ETag') || headers.key?('Last-Modified')
-      end
-
-      def digest_body(body)
-        parts = []
-        body.each { |part| parts << part }
-        string_body = parts.join
-        digest = Digest::MD5.hexdigest(string_body) unless string_body.empty?
-        [digest, parts]
-      end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/file.rb

@@ -1,138 +0,0 @@
-require 'time'
-require 'rack/utils'
-require 'rack/mime'
-
-module Rack
-  # Rack::File serves files below the +root+ directory given, according to the
-  # path info of the Rack request.
-  # e.g. when Rack::File.new("/etc") is used, you can access 'passwd' file
-  # as http://localhost:9292/passwd
-  #
-  # Handlers can detect if bodies are a Rack::File, and use mechanisms
-  # like sendfile on the +path+.
-
-  class File
-    SEPS = Regexp.union(*[::File::SEPARATOR, ::File::ALT_SEPARATOR].compact)
-    ALLOWED_VERBS = %w[GET HEAD]
-
-    attr_accessor :root
-    attr_accessor :path
-    attr_accessor :cache_control
-
-    alias :to_path :path
-
-    def initialize(root, headers={}, default_mime = 'text/plain')
-      @root = root
-      @headers = headers
-      @default_mime = default_mime
-    end
-
-    def call(env)
-      dup._call(env)
-    end
-
-    F = ::File
-
-    def _call(env)
-      unless ALLOWED_VERBS.include? env["REQUEST_METHOD"]
-        return fail(405, "Method Not Allowed")
-      end
-
-      path_info = Utils.unescape(env["PATH_INFO"])
-      parts = path_info.split SEPS
-
-      clean = []
-
-      parts.each do |part|
-        next if part.empty? || part == '.'
-        part == '..' ? clean.pop : clean << part
-      end
-
-      @path = F.join(@root, *clean)
-
-      available = begin
-        F.file?(@path) && F.readable?(@path)
-      rescue SystemCallError
-        false
-      end
-
-      if available
-        serving(env)
-      else
-        fail(404, "File not found: #{path_info}")
-      end
-    end
-
-    def serving(env)
-      last_modified = F.mtime(@path).httpdate
-      return [304, {}, []] if env['HTTP_IF_MODIFIED_SINCE'] == last_modified
-
-      headers = { "Last-Modified" => last_modified }
-      mime = Mime.mime_type(F.extname(@path), @default_mime)
-      headers["Content-Type"] = mime if mime
-
-      # Set custom headers
-      @headers.each { |field, content| headers[field] = content } if @headers
-
-      response = [ 200, headers, env["REQUEST_METHOD"] == "HEAD" ? [] : self ]
-
-      # NOTE:
-      #   We check via File::size? whether this file provides size info
-      #   via stat (e.g. /proc files often don't), otherwise we have to
-      #   figure it out by reading the whole file into memory.
-      size = F.size?(@path) || Utils.bytesize(F.read(@path))
-
-      ranges = Rack::Utils.byte_ranges(env, size)
-      if ranges.nil? || ranges.length > 1
-        # No ranges, or multiple ranges (which we don't support):
-        # TODO: Support multiple byte-ranges
-        response[0] = 200
-        @range = 0..size-1
-      elsif ranges.empty?
-        # Unsatisfiable. Return error, and file size:
-        response = fail(416, "Byte range unsatisfiable")
-        response[1]["Content-Range"] = "bytes */#{size}"
-        return response
-      else
-        # Partial content:
-        @range = ranges[0]
-        response[0] = 206
-        response[1]["Content-Range"] = "bytes #{@range.begin}-#{@range.end}/#{size}"
-        size = @range.end - @range.begin + 1
-      end
-
-      response[1]["Content-Length"] = size.to_s
-      response
-    end
-
-    def each
-      F.open(@path, "rb") do |file|
-        file.seek(@range.begin)
-        remaining_len = @range.end-@range.begin+1
-        while remaining_len > 0
-          part = file.read([8192, remaining_len].min)
-          break unless part
-          remaining_len -= part.length
-
-          yield part
-        end
-      end
-    end
-
-    private
-
-    def fail(status, body)
-      body += "\n"
-      [
-        status,
-        {
-          "Content-Type" => "text/plain",
-          "Content-Length" => body.size.to_s,
-          "X-Cascade" => "pass"
-        },
-        [body]
-      ]
-    end
-
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/handler.rb

@@ -1,107 +0,0 @@
-module Rack
-  # *Handlers* connect web servers with Rack.
-  #
-  # Rack includes Handlers for Thin, WEBrick, FastCGI, CGI, SCGI
-  # and LiteSpeed.
-  #
-  # Handlers usually are activated by calling <tt>MyHandler.run(myapp)</tt>.
-  # A second optional hash can be passed to include server-specific
-  # configuration.
-  module Handler
-    def self.get(server)
-      return unless server
-      server = server.to_s
-
-      unless @handlers.include? server
-        load_error = try_require('rack/handler', server)
-      end
-
-      if klass = @handlers[server]
-        klass.split("::").inject(Object) { |o, x| o.const_get(x) }
-      else
-        const_get(server)
-      end
-
-    rescue NameError => name_error
-      raise load_error || name_error
-    end
-
-    # Select first available Rack handler given an `Array` of server names.
-    # Raises `LoadError` if no handler was found.
-    #
-    #   > pick ['thin', 'webrick']
-    #   => Rack::Handler::WEBrick
-    def self.pick(server_names)
-      server_names = Array(server_names)
-      server_names.each do |server_name|
-        begin
-          return get(server_name.to_s)
-        rescue LoadError, NameError
-        end
-      end
-
-      raise LoadError, "Couldn't find handler for: #{server_names.join(', ')}."
-    end
-
-    def self.default(options = {})
-      # Guess.
-      if ENV.include?("PHP_FCGI_CHILDREN")
-        # We already speak FastCGI
-        options.delete :File
-        options.delete :Port
-
-        Rack::Handler::FastCGI
-      elsif ENV.include?("REQUEST_METHOD")
-        Rack::Handler::CGI
-      else
-        pick ['thin', 'puma', 'webrick']
-      end
-    end
-
-    # Transforms server-name constants to their canonical form as filenames,
-    # then tries to require them but silences the LoadError if not found
-    #
-    # Naming convention:
-    #
-    #   Foo # => 'foo'
-    #   FooBar # => 'foo_bar.rb'
-    #   FooBAR # => 'foobar.rb'
-    #   FOObar # => 'foobar.rb'
-    #   FOOBAR # => 'foobar.rb'
-    #   FooBarBaz # => 'foo_bar_baz.rb'
-    def self.try_require(prefix, const_name)
-      file = const_name.gsub(/^[A-Z]+/) { |pre| pre.downcase }.
-        gsub(/[A-Z]+[^A-Z]/, '_\&').downcase
-
-      require(::File.join(prefix, file))
-      nil
-    rescue LoadError => error
-      error
-    end
-
-    def self.register(server, klass)
-      @handlers ||= {}
-      @handlers[server.to_s] = klass.to_s
-    end
-
-    autoload :CGI, "rack/handler/cgi"
-    autoload :FastCGI, "rack/handler/fastcgi"
-    autoload :Mongrel, "rack/handler/mongrel"
-    autoload :EventedMongrel, "rack/handler/evented_mongrel"
-    autoload :SwiftipliedMongrel, "rack/handler/swiftiplied_mongrel"
-    autoload :WEBrick, "rack/handler/webrick"
-    autoload :LSWS, "rack/handler/lsws"
-    autoload :SCGI, "rack/handler/scgi"
-    autoload :Thin, "rack/handler/thin"
-
-    register 'cgi', 'Rack::Handler::CGI'
-    register 'fastcgi', 'Rack::Handler::FastCGI'
-    register 'mongrel', 'Rack::Handler::Mongrel'
-    register 'emongrel', 'Rack::Handler::EventedMongrel'
-    register 'smongrel', 'Rack::Handler::SwiftipliedMongrel'
-    register 'webrick', 'Rack::Handler::WEBrick'
-    register 'lsws', 'Rack::Handler::LSWS'
-    register 'scgi', 'Rack::Handler::SCGI'
-    register 'thin', 'Rack::Handler::Thin'
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/handler/cgi.rb

@@ -1,61 +0,0 @@
-require 'rack/content_length'
-require 'rack/rewindable_input'
-
-module Rack
-  module Handler
-    class CGI
-      def self.run(app, options=nil)
-        $stdin.binmode
-        serve app
-      end
-
-      def self.serve(app)
-        env = ENV.to_hash
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => Rack::RewindableInput.new($stdin),
-                     "rack.errors" => $stderr,
-
-                     "rack.multithread" => false,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => true,
-
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(ENV["HTTPS"]) ? "https" : "http"
-                   })
-
-        env["QUERY_STRING"] ||= ""
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["REQUEST_PATH"] ||= "/"
-
-        status, headers, body = app.call(env)
-        begin
-          send_headers status, headers
-          send_body body
-        ensure
-          body.close  if body.respond_to? :close
-        end
-      end
-
-      def self.send_headers(status, headers)
-        $stdout.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            $stdout.print "#{k}: #{v}\r\n"
-          }
-        }
-        $stdout.print "\r\n"
-        $stdout.flush
-      end
-
-      def self.send_body(body)
-        body.each { |part|
-          $stdout.print part
-          $stdout.flush
-        }
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/handler/evented_mongrel.rb

@@ -1,8 +0,0 @@
-require 'swiftcore/evented_mongrel'
-
-module Rack
-  module Handler
-    class EventedMongrel < Handler::Mongrel
-    end
-  end
-end

data/vendor/bundle/ruby/1.8/gems/rack-1.5.2/lib/rack/handler/fastcgi.rb

@@ -1,98 +0,0 @@
-require 'fcgi'
-require 'socket'
-require 'rack/content_length'
-require 'rack/rewindable_input'
-
-if defined? FCGI::Stream
-  class FCGI::Stream
-    alias _rack_read_without_buffer read
-
-    def read(n, buffer=nil)
-      buf = _rack_read_without_buffer n
-      buffer.replace(buf.to_s)  if buffer
-      buf
-    end
-  end
-end
-
-module Rack
-  module Handler
-    class FastCGI
-      def self.run(app, options={})
-        if options[:File]
-          STDIN.reopen(UNIXServer.new(options[:File]))
-        elsif options[:Port]
-          STDIN.reopen(TCPServer.new(options[:Host], options[:Port]))
-        end
-        FCGI.each { |request|
-          serve request, app
-        }
-      end
-
-      def self.valid_options
-        {
-          "Host=HOST" => "Hostname to listen on (default: localhost)",
-          "Port=PORT" => "Port to listen on (default: 8080)",
-          "File=PATH" => "Creates a Domain socket at PATH instead of a TCP socket. Ignores Host and Port if set.",
-        }
-      end
-
-      def self.serve(request, app)
-        env = request.env
-        env.delete "HTTP_CONTENT_LENGTH"
-
-        env["SCRIPT_NAME"] = ""  if env["SCRIPT_NAME"] == "/"
-
-        rack_input = RewindableInput.new(request.in)
-
-        env.update({"rack.version" => Rack::VERSION,
-                     "rack.input" => rack_input,
-                     "rack.errors" => request.err,
-
-                     "rack.multithread" => false,
-                     "rack.multiprocess" => true,
-                     "rack.run_once" => false,
-
-                     "rack.url_scheme" => ["yes", "on", "1"].include?(env["HTTPS"]) ? "https" : "http"
-                   })
-
-        env["QUERY_STRING"] ||= ""
-        env["HTTP_VERSION"] ||= env["SERVER_PROTOCOL"]
-        env["REQUEST_PATH"] ||= "/"
-        env.delete "CONTENT_TYPE"  if env["CONTENT_TYPE"] == ""
-        env.delete "CONTENT_LENGTH"  if env["CONTENT_LENGTH"] == ""
-
-        begin
-          status, headers, body = app.call(env)
-          begin
-            send_headers request.out, status, headers
-            send_body request.out, body
-          ensure
-            body.close  if body.respond_to? :close
-          end
-        ensure
-          rack_input.close
-          request.finish
-        end
-      end
-
-      def self.send_headers(out, status, headers)
-        out.print "Status: #{status}\r\n"
-        headers.each { |k, vs|
-          vs.split("\n").each { |v|
-            out.print "#{k}: #{v}\r\n"
-          }
-        }
-        out.print "\r\n"
-        out.flush
-      end
-
-      def self.send_body(out, body)
-        body.each { |part|
-          out.print part
-          out.flush
-        }
-      end
-    end
-  end
-end