sprokovuln 0.2.0

data/vendor/ruby/gems/rack-2.0.5/lib/rack/static.rb

@@ -0,0 +1,175 @@
+require "rack/file"
+require "rack/utils"
+
+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|woff2|woff|svg)\z/ => Matches files ending in
+  #       the most common web font formats (.eot, .ttf, .otf, .woff2, .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]
+      @gzip = options[:gzip]
+      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.unshift([:all, {CACHE_CONTROL => options[:cache_control]}]) if options[:cache_control]
+
+      @file_server = Rack::File.new(root)
+    end
+
+    def add_index_root?(path)
+      @index && path =~ /\/$/
+    end
+
+    def overwrite_file_path(path)
+      @urls.kind_of?(Hash) && @urls.key?(path) || add_index_root?(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)
+        if overwrite_file_path(path)
+          env[PATH_INFO] = (add_index_root?(path) ? path + @index : @urls[path])
+        elsif @gzip && env['HTTP_ACCEPT_ENCODING'] =~ /\bgzip\b/
+          path = env[PATH_INFO]
+          env[PATH_INFO] += '.gz'
+          response = @file_server.call(env)
+          env[PATH_INFO] = path
+
+          if response[0] == 404
+            response = nil
+          else
+            if mime_type = Mime.mime_type(::File.extname(path), 'text/plain')
+              response[1][CONTENT_TYPE] = mime_type
+            end
+            response[1]['Content-Encoding'] = 'gzip'
+          end
+        end
+
+        path = env[PATH_INFO]
+        response ||= @file_server.call(env)
+
+        headers = response[1]
+        applicable_rules(path).each do |rule, new_headers|
+          new_headers.each { |field, content| headers[field] = content }
+        end
+
+        response
+      else
+        @app.call(env)
+      end
+    end
+
+    # Convert HTTP header rules to HTTP headers
+    def applicable_rules(path)
+      @header_rules.find_all do |rule, new_headers|
+        case rule
+        when :all
+          true
+        when :fonts
+          path =~ /\.(?:ttf|otf|eot|woff2|woff|svg)\z/
+        when String
+          path = ::Rack::Utils.unescape(path)
+          path.start_with?(rule) || path.start_with?('/' + rule)
+        when Array
+          path =~ /\.(#{rule.join('|')})\z/
+        when Regexp
+          path =~ rule
+        else
+          false
+        end
+      end
+    end
+
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/tempfile_reaper.rb

@@ -0,0 +1,22 @@
+require 'rack/body_proxy'
+
+module Rack
+
+  # Middleware tracks and cleans Tempfiles created throughout a request (i.e. Rack::Multipart)
+  # Ideas/strategy based on posts by Eric Wong and Charles Oliver Nutter
+  # https://groups.google.com/forum/#!searchin/rack-devel/temp/rack-devel/brK8eh-MByw/sw61oJJCGRMJ
+  class TempfileReaper
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env[RACK_TEMPFILES] ||= []
+      status, headers, body = @app.call(env)
+      body_proxy = BodyProxy.new(body) do
+        env[RACK_TEMPFILES].each(&:close!) unless env[RACK_TEMPFILES].nil?
+      end
+      [status, headers, body_proxy]
+    end
+  end
+end

data/vendor/ruby/gems/rack-2.0.5/lib/rack/urlmap.rb

@@ -0,0 +1,91 @@
+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]
+      http_host   = env[HTTP_HOST]
+      server_name = env[SERVER_NAME]
+      server_port = env[SERVER_PORT]
+
+      is_same_server = casecmp?(http_host, server_name) ||
+                       casecmp?(http_host, "#{server_name}:#{server_port}")
+
+      @mapping.each do |host, location, match, app|
+        unless casecmp?(http_host, host) \
+            || casecmp?(server_name, host) \
+            || (!host && is_same_server)
+          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
+
+    private
+    def casecmp?(v1, v2)
+      # if both nil, or they're the same string
+      return true if v1 == v2
+
+      # if either are nil... (but they're not the same)
+      return false if v1.nil?
+      return false if v2.nil?
+
+      # otherwise check they're not case-insensitive the same
+      v1.casecmp(v2).zero?
+    end
+  end
+end