scout_realtime 0.5.1

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

@@ -0,0 +1,153 @@
+module Rack
+
+  # The Rack::Static middleware intercepts requests for static files
+  # (javascript files, images, stylesheets, etc) based on the url prefixes or
+  # route mappings passed in the options, and serves them using a Rack::File
+  # object. This allows a Rack stack to serve both static and dynamic content.
+  #
+  # Examples:
+  #
+  # Serve all requests beginning with /media from the "media" folder located
+  # in the current directory (ie media/*):
+  #
+  #     use Rack::Static, :urls => ["/media"]
+  #
+  # Serve all requests beginning with /css or /images from the folder "public"
+  # in the current directory (ie public/css/* and public/images/*):
+  #
+  #     use Rack::Static, :urls => ["/css", "/images"], :root => "public"
+  #
+  # Serve all requests to / with "index.html" from the folder "public" in the
+  # current directory (ie public/index.html):
+  #
+  #     use Rack::Static, :urls => {"/" => 'index.html'}, :root => 'public'
+  #
+  # Serve all requests normally from the folder "public" in the current
+  # directory but uses index.html as default route for "/"
+  #
+  #     use Rack::Static, :urls => [""], :root => 'public', :index =>
+  #     'index.html'
+  #
+  # Set custom HTTP Headers for based on rules:
+  #
+  #     use Rack::Static, :root => 'public',
+  #         :header_rules => [
+  #           [rule, {header_field => content, header_field => content}],
+  #           [rule, {header_field => content}]
+  #         ]
+  #
+  #  Rules for selecting files:
+  #
+  #  1) All files
+  #     Provide the :all symbol
+  #     :all => Matches every file
+  #
+  #  2) Folders
+  #     Provide the folder path as a string
+  #     '/folder' or '/folder/subfolder' => Matches files in a certain folder
+  #
+  #  3) File Extensions
+  #     Provide the file extensions as an array
+  #     ['css', 'js'] or %w(css js) => Matches files ending in .css or .js
+  #
+  #  4) Regular Expressions / Regexp
+  #     Provide a regular expression
+  #     %r{\.(?:css|js)\z} => Matches files ending in .css or .js
+  #     /\.(?:eot|ttf|otf|woff|svg)\z/ => Matches files ending in
+  #       the most common web font formats (.eot, .ttf, .otf, .woff, .svg)
+  #       Note: This Regexp is available as a shortcut, using the :fonts rule
+  #
+  #  5) Font Shortcut
+  #     Provide the :fonts symbol
+  #     :fonts => Uses the Regexp rule stated right above to match all common web font endings
+  #
+  #  Rule Ordering:
+  #    Rules are applied in the order that they are provided.
+  #    List rather general rules above special ones.
+  #
+  #  Complete example use case including HTTP header rules:
+  #
+  #     use Rack::Static, :root => 'public',
+  #         :header_rules => [
+  #           # Cache all static files in public caches (e.g. Rack::Cache)
+  #           #  as well as in the browser
+  #           [:all, {'Cache-Control' => 'public, max-age=31536000'}],
+  #
+  #           # Provide web fonts with cross-origin access-control-headers
+  #           #  Firefox requires this when serving assets using a Content Delivery Network
+  #           [:fonts, {'Access-Control-Allow-Origin' => '*'}]
+  #         ]
+  #
+  class Static
+
+    def initialize(app, options={})
+      @app = app
+      @urls = options[:urls] || ["/favicon.ico"]
+      @index = options[:index]
+      root = options[:root] || Dir.pwd
+
+      # HTTP Headers
+      @header_rules = options[:header_rules] || []
+      # Allow for legacy :cache_control option while prioritizing global header_rules setting
+      @header_rules.insert(0, [:all, {'Cache-Control' => options[:cache_control]}]) if options[:cache_control]
+      @headers = {}
+
+      @file_server = Rack::File.new(root, @headers)
+    end
+
+    def overwrite_file_path(path)
+      @urls.kind_of?(Hash) && @urls.key?(path) || @index && path =~ /\/$/
+    end
+
+    def route_file(path)
+      @urls.kind_of?(Array) && @urls.any? { |url| path.index(url) == 0 }
+    end
+
+    def can_serve(path)
+      route_file(path) || overwrite_file_path(path)
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+
+      if can_serve(path)
+        env["PATH_INFO"] = (path =~ /\/$/ ? path + @index : @urls[path]) if overwrite_file_path(path)
+        @path = env["PATH_INFO"]
+        apply_header_rules
+        @file_server.call(env)
+      else
+        @app.call(env)
+      end
+    end
+
+    # Convert HTTP header rules to HTTP headers
+    def apply_header_rules
+      @header_rules.each do |rule, headers|
+        apply_rule(rule, headers)
+      end
+    end
+
+    def apply_rule(rule, headers)
+      case rule
+      when :all    # All files
+        set_headers(headers)
+      when :fonts  # Fonts Shortcut
+        set_headers(headers) if @path.match(/\.(?:ttf|otf|eot|woff|svg)\z/)
+      when String  # Folder
+        path = ::Rack::Utils.unescape(@path)
+        set_headers(headers) if (path.start_with?(rule) || path.start_with?('/' + rule))
+      when Array   # Extension/Extensions
+        extensions = rule.join('|')
+        set_headers(headers) if @path.match(/\.(#{extensions})\z/)
+      when Regexp  # Flexible Regexp
+        set_headers(headers) if @path.match(rule)
+      else
+      end
+    end
+
+    def set_headers(headers)
+      headers.each { |field, content| @headers[field] = content }
+    end
+
+  end
+end

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

@@ -0,0 +1,76 @@
+module Rack
+  # Rack::URLMap takes a hash mapping urls or paths to apps, and
+  # dispatches accordingly.  Support for HTTP/1.1 host names exists if
+  # the URLs start with <tt>http://</tt> or <tt>https://</tt>.
+  #
+  # URLMap modifies the SCRIPT_NAME and PATH_INFO such that the part
+  # relevant for dispatch is in the SCRIPT_NAME, and the rest in the
+  # PATH_INFO.  This should be taken care of when you need to
+  # reconstruct the URL in order to create links.
+  #
+  # URLMap dispatches in such a way that the longest paths are tried
+  # first, since they are most specific.
+
+  class URLMap
+    NEGATIVE_INFINITY = -1.0 / 0.0
+    INFINITY = 1.0 / 0.0
+
+    def initialize(map = {})
+      remap(map)
+    end
+
+    def remap(map)
+      @mapping = map.map { |location, app|
+        if location =~ %r{\Ahttps?://(.*?)(/.*)}
+          host, location = $1, $2
+        else
+          host = nil
+        end
+
+        unless location[0] == ?/
+          raise ArgumentError, "paths need to start with /"
+        end
+
+        location = location.chomp('/')
+        match = Regexp.new("^#{Regexp.quote(location).gsub('/', '/+')}(.*)", nil, 'n')
+
+        [host, location, match, app]
+      }.sort_by do |(host, location, _, _)|
+        [host ? -host.size : INFINITY, -location.size]
+      end
+    end
+
+    def call(env)
+      path = env["PATH_INFO"]
+      script_name = env['SCRIPT_NAME']
+      hHost = env['HTTP_HOST']
+      sName = env['SERVER_NAME']
+      sPort = env['SERVER_PORT']
+
+      @mapping.each do |host, location, match, app|
+        unless hHost == host \
+            || sName == host \
+            || (!host && (hHost == sName || hHost == sName+':'+sPort))
+          next
+        end
+
+        next unless m = match.match(path.to_s)
+
+        rest = m[1]
+        next unless !rest || rest.empty? || rest[0] == ?/
+
+        env['SCRIPT_NAME'] = (script_name + location)
+        env['PATH_INFO'] = rest
+
+        return app.call(env)
+      end
+
+      [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+
+    ensure
+      env['PATH_INFO'] = path
+      env['SCRIPT_NAME'] = script_name
+    end
+  end
+end
+