scout_realtime 0.5.1

data/lib/vendor/rack-1.5.2/lib/rack/cascade.rb

@@ -0,0 +1,52 @@
+module Rack
+  # Rack::Cascade tries a request on several apps, and returns the
+  # first response that is not 404 or 405 (or in a list of configurable
+  # status codes).
+
+  class Cascade
+    NotFound = [404, {"Content-Type" => "text/plain"}, []]
+
+    attr_reader :apps
+
+    def initialize(apps, catch=[404, 405])
+      @apps = []; @has_app = {}
+      apps.each { |app| add app }
+
+      @catch = {}
+      [*catch].each { |status| @catch[status] = true }
+    end
+
+    def call(env)
+      result = NotFound
+
+      last_body = nil
+
+      @apps.each do |app|
+        # The SPEC says that the body must be closed after it has been iterated
+        # by the server, or if it is replaced by a middleware action. Cascade
+        # replaces the body each time a cascade happens. It is assumed that nil
+        # does not respond to close, otherwise the previous application body
+        # will be closed. The final application body will not be closed, as it
+        # will be passed to the server as a result.
+        last_body.close if last_body.respond_to? :close
+
+        result = app.call(env)
+        last_body = result[2]
+        break unless @catch.include?(result[0].to_i)
+      end
+
+      result
+    end
+
+    def add app
+      @has_app[app] = true
+      @apps << app
+    end
+
+    def include? app
+      @has_app.include? app
+    end
+
+    alias_method :<<, :add
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/chunked.rb

@@ -0,0 +1,58 @@
+require 'rack/utils'
+
+module Rack
+
+  # Middleware that applies chunked transfer encoding to response bodies
+  # when the response does not include a Content-Length header.
+  class Chunked
+    include Rack::Utils
+
+    # A body wrapper that emits chunked responses
+    class Body
+      TERM = "\r\n"
+      TAIL = "0#{TERM}#{TERM}"
+
+      include Rack::Utils
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        term = TERM
+        @body.each do |chunk|
+          size = bytesize(chunk)
+          next if size == 0
+
+          chunk = chunk.dup.force_encoding(Encoding::BINARY) if chunk.respond_to?(:force_encoding)
+          yield [size.to_s(16), term, chunk, term].join
+        end
+        yield TAIL
+      end
+
+      def close
+        @body.close if @body.respond_to?(:close)
+      end
+    end
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = HeaderHash.new(headers)
+
+      if env['HTTP_VERSION'] == 'HTTP/1.0' ||
+         STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+         headers['Content-Length'] ||
+         headers['Transfer-Encoding']
+        [status, headers, body]
+      else
+        headers.delete('Content-Length')
+        headers['Transfer-Encoding'] = 'chunked'
+        [status, headers, Body.new(body)]
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/commonlogger.rb

@@ -0,0 +1,64 @@
+require 'rack/body_proxy'
+
+module Rack
+  # Rack::CommonLogger forwards every request to the given +app+, and
+  # logs a line in the
+  # {Apache common log format}[http://httpd.apache.org/docs/1.3/logs.html#common]
+  # to the +logger+.
+  #
+  # If +logger+ is nil, CommonLogger will fall back +rack.errors+, which is
+  # an instance of Rack::NullLogger.
+  #
+  # +logger+ can be any class, including the standard library Logger, and is
+  # expected to have a +write+ method, which accepts the CommonLogger::FORMAT.
+  # According to the SPEC, the error stream must also respond to +puts+
+  # (which takes a single argument that responds to +to_s+), and +flush+
+  # (which is called without arguments in order to make the error appear for
+  # sure)
+  class CommonLogger
+    # Common Log Format: http://httpd.apache.org/docs/1.3/logs.html#common
+    #
+    #   lilith.local - - [07/Aug/2006 23:58:02] "GET / HTTP/1.1" 500 -
+    #
+    #   %{%s - %s [%s] "%s %s%s %s" %d %s\n} %
+    FORMAT = %{%s - %s [%s] "%s %s%s %s" %d %s %0.4f\n}
+
+    def initialize(app, logger=nil)
+      @app = app
+      @logger = logger
+    end
+
+    def call(env)
+      began_at = Time.now
+      status, header, body = @app.call(env)
+      header = Utils::HeaderHash.new(header)
+      body = BodyProxy.new(body) { log(env, status, header, began_at) }
+      [status, header, body]
+    end
+
+    private
+
+    def log(env, status, header, began_at)
+      now = Time.now
+      length = extract_content_length(header)
+
+      logger = @logger || env['rack.errors']
+      logger.write FORMAT % [
+        env['HTTP_X_FORWARDED_FOR'] || env["REMOTE_ADDR"] || "-",
+        env["REMOTE_USER"] || "-",
+        now.strftime("%d/%b/%Y %H:%M:%S"),
+        env["REQUEST_METHOD"],
+        env["PATH_INFO"],
+        env["QUERY_STRING"].empty? ? "" : "?"+env["QUERY_STRING"],
+        env["HTTP_VERSION"],
+        status.to_s[0..3],
+        length,
+        now - began_at ]
+    end
+
+    def extract_content_length(headers)
+      value = headers['Content-Length'] or return '-'
+      value.to_s == '0' ? '-' : value
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/conditionalget.rb

@@ -0,0 +1,67 @@
+require 'rack/utils'
+
+module Rack
+
+  # Middleware that enables conditional GET using If-None-Match and
+  # If-Modified-Since. The application should set either or both of the
+  # Last-Modified or Etag response headers according to RFC 2616. When
+  # either of the conditions is met, the response body is set to be zero
+  # length and the response status is set to 304 Not Modified.
+  #
+  # Applications that defer response body generation until the body's each
+  # message is received will avoid response body generation completely when
+  # a conditional GET matches.
+  #
+  # Adapted from Michael Klishin's Merb implementation:
+  # https://github.com/wycats/merb/blob/master/merb-core/lib/merb-core/rack/middleware/conditional_get.rb
+  class ConditionalGet
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      case env['REQUEST_METHOD']
+      when "GET", "HEAD"
+        status, headers, body = @app.call(env)
+        headers = Utils::HeaderHash.new(headers)
+        if status == 200 && fresh?(env, headers)
+          status = 304
+          headers.delete('Content-Type')
+          headers.delete('Content-Length')
+          body = []
+        end
+        [status, headers, body]
+      else
+        @app.call(env)
+      end
+    end
+
+  private
+
+    def fresh?(env, headers)
+      modified_since = env['HTTP_IF_MODIFIED_SINCE']
+      none_match     = env['HTTP_IF_NONE_MATCH']
+
+      return false unless modified_since || none_match
+
+      success = true
+      success &&= modified_since?(to_rfc2822(modified_since), headers) if modified_since
+      success &&= etag_matches?(none_match, headers) if none_match
+      success
+    end
+
+    def etag_matches?(none_match, headers)
+      etag = headers['ETag'] and etag == none_match
+    end
+
+    def modified_since?(modified_since, headers)
+      last_modified = to_rfc2822(headers['Last-Modified']) and
+        modified_since and
+        modified_since >= last_modified
+    end
+
+    def to_rfc2822(since)
+      Time.rfc2822(since) rescue nil
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/config.rb

@@ -0,0 +1,20 @@
+module Rack
+  # Rack::Config modifies the environment using the block given during
+  # initialization.
+  #
+  # Example:
+  #     use Rack::Config do |env|
+  #       env['my-key'] = 'some-value'
+  #     end
+  class Config
+    def initialize(app, &block)
+      @app = app
+      @block = block
+    end
+
+    def call(env)
+      @block.call(env)
+      @app.call(env)
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/content_length.rb

@@ -0,0 +1,33 @@
+require 'rack/utils'
+
+module Rack
+
+  # Sets the Content-Length header on responses with fixed-length bodies.
+  class ContentLength
+    include Rack::Utils
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = HeaderHash.new(headers)
+
+      if !STATUS_WITH_NO_ENTITY_BODY.include?(status.to_i) &&
+         !headers['Content-Length'] &&
+         !headers['Transfer-Encoding'] &&
+         body.respond_to?(:to_ary)
+
+        obody = body
+        body, length = [], 0
+        obody.each { |part| body << part; length += bytesize(part) }
+        obody.close if obody.respond_to?(:close)
+
+        headers['Content-Length'] = length.to_s
+      end
+
+      [status, headers, body]
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/content_type.rb

@@ -0,0 +1,29 @@
+require 'rack/utils'
+
+module Rack
+
+  # Sets the Content-Type header on responses which don't have one.
+  #
+  # Builder Usage:
+  #   use Rack::ContentType, "text/plain"
+  #
+  # When no content type argument is provided, "text/html" is assumed.
+  class ContentType
+    include Rack::Utils
+
+    def initialize(app, content_type = "text/html")
+      @app, @content_type = app, content_type
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+
+      unless STATUS_WITH_NO_ENTITY_BODY.include?(status)
+        headers['Content-Type'] ||= @content_type
+      end
+
+      [status, headers, body]
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/deflater.rb

@@ -0,0 +1,116 @@
+require "zlib"
+require "stringio"
+require "time"  # for Time.httpdate
+require 'rack/utils'
+
+module Rack
+  # This middleware enables compression of http responses.
+  #
+  # Currently supported compression algorithms:
+  #
+  #   * gzip
+  #   * deflate
+  #   * identity (no transformation)
+  #
+  # The middleware automatically detects when compression is supported
+  # and allowed. For example no transformation is made when a cache
+  # directive of 'no-transform' is present, or when the response status
+  # code is one that doesn't allow an entity body.
+  class Deflater
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      status, headers, body = @app.call(env)
+      headers = Utils::HeaderHash.new(headers)
+
+      # Skip compressing empty entity body responses and responses with
+      # no-transform set.
+      if Utils::STATUS_WITH_NO_ENTITY_BODY.include?(status) ||
+          headers['Cache-Control'].to_s =~ /\bno-transform\b/ ||
+         (headers['Content-Encoding'] && headers['Content-Encoding'] !~ /\bidentity\b/)
+        return [status, headers, body]
+      end
+
+      request = Request.new(env)
+
+      encoding = Utils.select_best_encoding(%w(gzip deflate identity),
+                                            request.accept_encoding)
+
+      # Set the Vary HTTP header.
+      vary = headers["Vary"].to_s.split(",").map { |v| v.strip }
+      unless vary.include?("*") || vary.include?("Accept-Encoding")
+        headers["Vary"] = vary.push("Accept-Encoding").join(",")
+      end
+
+      case encoding
+      when "gzip"
+        headers['Content-Encoding'] = "gzip"
+        headers.delete('Content-Length')
+        mtime = headers.key?("Last-Modified") ?
+          Time.httpdate(headers["Last-Modified"]) : Time.now
+        [status, headers, GzipStream.new(body, mtime)]
+      when "deflate"
+        headers['Content-Encoding'] = "deflate"
+        headers.delete('Content-Length')
+        [status, headers, DeflateStream.new(body)]
+      when "identity"
+        [status, headers, body]
+      when nil
+        body.close if body.respond_to?(:close)
+        message = "An acceptable encoding for the requested resource #{request.fullpath} could not be found."
+        [406, {"Content-Type" => "text/plain", "Content-Length" => message.length.to_s}, [message]]
+      end
+    end
+
+    class GzipStream
+      def initialize(body, mtime)
+        @body = body
+        @mtime = mtime
+      end
+
+      def each(&block)
+        @writer = block
+        gzip  =::Zlib::GzipWriter.new(self)
+        gzip.mtime = @mtime
+        @body.each { |part|
+          gzip.write(part)
+          gzip.flush
+        }
+      ensure
+        @body.close if @body.respond_to?(:close)
+        gzip.close
+        @writer = nil
+      end
+
+      def write(data)
+        @writer.call(data)
+      end
+    end
+
+    class DeflateStream
+      DEFLATE_ARGS = [
+        Zlib::DEFAULT_COMPRESSION,
+        # drop the zlib header which causes both Safari and IE to choke
+        -Zlib::MAX_WBITS,
+        Zlib::DEF_MEM_LEVEL,
+        Zlib::DEFAULT_STRATEGY
+      ]
+
+      def initialize(body)
+        @body = body
+      end
+
+      def each
+        deflater = ::Zlib::Deflate.new(*DEFLATE_ARGS)
+        @body.each { |part| yield deflater.deflate(part, Zlib::SYNC_FLUSH) }
+        yield deflater.finish
+        nil
+      ensure
+        @body.close if @body.respond_to?(:close)
+        deflater.close
+      end
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/directory.rb

@@ -0,0 +1,161 @@
+require 'time'
+require 'rack/utils'
+require 'rack/mime'
+
+module Rack
+  # Rack::Directory serves entries below the +root+ given, according to the
+  # path info of the Rack request. If a directory is found, the file's contents
+  # will be presented in an html based index. If a file is found, the env will
+  # be passed to the specified +app+.
+  #
+  # If +app+ is not specified, a Rack::File of the same +root+ will be used.
+
+  class Directory
+    DIR_FILE = "<tr><td class='name'><a href='%s'>%s</a></td><td class='size'>%s</td><td class='type'>%s</td><td class='mtime'>%s</td></tr>"
+    DIR_PAGE = <<-PAGE
+<html><head>
+  <title>%s</title>
+  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
+  <style type='text/css'>
+table { width:100%%; }
+.name { text-align:left; }
+.size, .mtime { text-align:right; }
+.type { width:11em; }
+.mtime { width:15em; }
+  </style>
+</head><body>
+<h1>%s</h1>
+<hr />
+<table>
+  <tr>
+    <th class='name'>Name</th>
+    <th class='size'>Size</th>
+    <th class='type'>Type</th>
+    <th class='mtime'>Last Modified</th>
+  </tr>
+%s
+</table>
+<hr />
+</body></html>
+    PAGE
+
+    attr_reader :files
+    attr_accessor :root, :path
+
+    def initialize(root, app=nil)
+      @root = F.expand_path(root)
+      @app = app || Rack::File.new(@root)
+    end
+
+    def call(env)
+      dup._call(env)
+    end
+
+    F = ::File
+
+    def _call(env)
+      @env = env
+      @script_name = env['SCRIPT_NAME']
+      @path_info = Utils.unescape(env['PATH_INFO'])
+
+      if forbidden = check_forbidden
+        forbidden
+      else
+        @path = F.join(@root, @path_info)
+        list_path
+      end
+    end
+
+    def check_forbidden
+      return unless @path_info.include? ".."
+
+      body = "Forbidden\n"
+      size = Rack::Utils.bytesize(body)
+      return [403, {"Content-Type" => "text/plain",
+        "Content-Length" => size.to_s,
+        "X-Cascade" => "pass"}, [body]]
+    end
+
+    def list_directory
+      @files = [['../','Parent Directory','','','']]
+      glob = F.join(@path, '*')
+
+      url_head = (@script_name.split('/') + @path_info.split('/')).map do |part|
+        Rack::Utils.escape part
+      end
+
+      Dir[glob].sort.each do |node|
+        stat = stat(node)
+        next  unless stat
+        basename = F.basename(node)
+        ext = F.extname(node)
+
+        url = F.join(*url_head + [Rack::Utils.escape(basename)])
+        size = stat.size
+        type = stat.directory? ? 'directory' : Mime.mime_type(ext)
+        size = stat.directory? ? '-' : filesize_format(size)
+        mtime = stat.mtime.httpdate
+        url << '/'  if stat.directory?
+        basename << '/'  if stat.directory?
+
+        @files << [ url, basename, size, type, mtime ]
+      end
+
+      return [ 200, {'Content-Type'=>'text/html; charset=utf-8'}, self ]
+    end
+
+    def stat(node, max = 10)
+      F.stat(node)
+    rescue Errno::ENOENT, Errno::ELOOP
+      return nil
+    end
+
+    # TODO: add correct response if not readable, not sure if 404 is the best
+    #       option
+    def list_path
+      @stat = F.stat(@path)
+
+      if @stat.readable?
+        return @app.call(@env) if @stat.file?
+        return list_directory if @stat.directory?
+      else
+        raise Errno::ENOENT, 'No such file or directory'
+      end
+
+    rescue Errno::ENOENT, Errno::ELOOP
+      return entity_not_found
+    end
+
+    def entity_not_found
+      body = "Entity not found: #{@path_info}\n"
+      size = Rack::Utils.bytesize(body)
+      return [404, {"Content-Type" => "text/plain",
+        "Content-Length" => size.to_s,
+        "X-Cascade" => "pass"}, [body]]
+    end
+
+    def each
+      show_path = @path.sub(/^#{@root}/,'')
+      files = @files.map{|f| DIR_FILE % f }*"\n"
+      page  = DIR_PAGE % [ show_path, show_path , files ]
+      page.each_line{|l| yield l }
+    end
+
+    # Stolen from Ramaze
+
+    FILESIZE_FORMAT = [
+      ['%.1fT', 1 << 40],
+      ['%.1fG', 1 << 30],
+      ['%.1fM', 1 << 20],
+      ['%.1fK', 1 << 10],
+    ]
+
+    def filesize_format(int)
+      FILESIZE_FORMAT.each do |format, size|
+        return format % (int.to_f / size) if int >= size
+      end
+
+      int.to_s + 'B'
+    end
+  end
+end

data/lib/vendor/rack-1.5.2/lib/rack/etag.rb

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