akamai_bookmarklet 0.1.0

data/vendor/gems/ruby/1.8/gems/rack-1.1.0/lib/rack/methodoverride.rb

@@ -0,0 +1,27 @@
+module Rack
+  class MethodOverride
+    HTTP_METHODS = %w(GET HEAD PUT POST DELETE OPTIONS)
+
+    METHOD_OVERRIDE_PARAM_KEY = "_method".freeze
+    HTTP_METHOD_OVERRIDE_HEADER = "HTTP_X_HTTP_METHOD_OVERRIDE".freeze
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      if env["REQUEST_METHOD"] == "POST"
+        req = Request.new(env)
+        method = req.POST[METHOD_OVERRIDE_PARAM_KEY] ||
+          env[HTTP_METHOD_OVERRIDE_HEADER]
+        method = method.to_s.upcase
+        if HTTP_METHODS.include?(method)
+          env["rack.methodoverride.original_method"] = env["REQUEST_METHOD"]
+          env["REQUEST_METHOD"] = method
+        end
+      end
+
+      @app.call(env)
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/rack-1.1.0/lib/rack/mime.rb

@@ -0,0 +1,206 @@
+module Rack
+  module Mime
+    # Returns String with mime type if found, otherwise use +fallback+.
+    # +ext+ should be filename extension in the '.ext' format that
+    #       File.extname(file) returns.
+    # +fallback+ may be any object
+    #
+    # Also see the documentation for MIME_TYPES
+    #
+    # Usage:
+    #     Rack::Mime.mime_type('.foo')
+    #
+    # This is a shortcut for:
+    #     Rack::Mime::MIME_TYPES.fetch('.foo', 'application/octet-stream')
+
+    def mime_type(ext, fallback='application/octet-stream')
+      MIME_TYPES.fetch(ext.to_s.downcase, fallback)
+    end
+    module_function :mime_type
+
+    # List of most common mime-types, selected various sources
+    # according to their usefulness in a webserving scope for Ruby
+    # users.
+    #
+    # To amend this list with your local mime.types list you can use:
+    #
+    #     require 'webrick/httputils'
+    #     list = WEBrick::HTTPUtils.load_mime_types('/etc/mime.types')
+    #     Rack::Mime::MIME_TYPES.merge!(list)
+    #
+    # To add the list mongrel provides, use:
+    #
+    #     require 'mongrel/handlers'
+    #     Rack::Mime::MIME_TYPES.merge!(Mongrel::DirHandler::MIME_TYPES)
+
+    MIME_TYPES = {
+      ".3gp"     => "video/3gpp",
+      ".a"       => "application/octet-stream",
+      ".ai"      => "application/postscript",
+      ".aif"     => "audio/x-aiff",
+      ".aiff"    => "audio/x-aiff",
+      ".asc"     => "application/pgp-signature",
+      ".asf"     => "video/x-ms-asf",
+      ".asm"     => "text/x-asm",
+      ".asx"     => "video/x-ms-asf",
+      ".atom"    => "application/atom+xml",
+      ".au"      => "audio/basic",
+      ".avi"     => "video/x-msvideo",
+      ".bat"     => "application/x-msdownload",
+      ".bin"     => "application/octet-stream",
+      ".bmp"     => "image/bmp",
+      ".bz2"     => "application/x-bzip2",
+      ".c"       => "text/x-c",
+      ".cab"     => "application/vnd.ms-cab-compressed",
+      ".cc"      => "text/x-c",
+      ".chm"     => "application/vnd.ms-htmlhelp",
+      ".class"   => "application/octet-stream",
+      ".com"     => "application/x-msdownload",
+      ".conf"    => "text/plain",
+      ".cpp"     => "text/x-c",
+      ".crt"     => "application/x-x509-ca-cert",
+      ".css"     => "text/css",
+      ".csv"     => "text/csv",
+      ".cxx"     => "text/x-c",
+      ".deb"     => "application/x-debian-package",
+      ".der"     => "application/x-x509-ca-cert",
+      ".diff"    => "text/x-diff",
+      ".djv"     => "image/vnd.djvu",
+      ".djvu"    => "image/vnd.djvu",
+      ".dll"     => "application/x-msdownload",
+      ".dmg"     => "application/octet-stream",
+      ".doc"     => "application/msword",
+      ".dot"     => "application/msword",
+      ".dtd"     => "application/xml-dtd",
+      ".dvi"     => "application/x-dvi",
+      ".ear"     => "application/java-archive",
+      ".eml"     => "message/rfc822",
+      ".eps"     => "application/postscript",
+      ".exe"     => "application/x-msdownload",
+      ".f"       => "text/x-fortran",
+      ".f77"     => "text/x-fortran",
+      ".f90"     => "text/x-fortran",
+      ".flv"     => "video/x-flv",
+      ".for"     => "text/x-fortran",
+      ".gem"     => "application/octet-stream",
+      ".gemspec" => "text/x-script.ruby",
+      ".gif"     => "image/gif",
+      ".gz"      => "application/x-gzip",
+      ".h"       => "text/x-c",
+      ".hh"      => "text/x-c",
+      ".htm"     => "text/html",
+      ".html"    => "text/html",
+      ".ico"     => "image/vnd.microsoft.icon",
+      ".ics"     => "text/calendar",
+      ".ifb"     => "text/calendar",
+      ".iso"     => "application/octet-stream",
+      ".jar"     => "application/java-archive",
+      ".java"    => "text/x-java-source",
+      ".jnlp"    => "application/x-java-jnlp-file",
+      ".jpeg"    => "image/jpeg",
+      ".jpg"     => "image/jpeg",
+      ".js"      => "application/javascript",
+      ".json"    => "application/json",
+      ".log"     => "text/plain",
+      ".m3u"     => "audio/x-mpegurl",
+      ".m4v"     => "video/mp4",
+      ".man"     => "text/troff",
+      ".manifest"=> "text/cache-manifest",
+      ".mathml"  => "application/mathml+xml",
+      ".mbox"    => "application/mbox",
+      ".mdoc"    => "text/troff",
+      ".me"      => "text/troff",
+      ".mid"     => "audio/midi",
+      ".midi"    => "audio/midi",
+      ".mime"    => "message/rfc822",
+      ".mml"     => "application/mathml+xml",
+      ".mng"     => "video/x-mng",
+      ".mov"     => "video/quicktime",
+      ".mp3"     => "audio/mpeg",
+      ".mp4"     => "video/mp4",
+      ".mp4v"    => "video/mp4",
+      ".mpeg"    => "video/mpeg",
+      ".mpg"     => "video/mpeg",
+      ".ms"      => "text/troff",
+      ".msi"     => "application/x-msdownload",
+      ".odp"     => "application/vnd.oasis.opendocument.presentation",
+      ".ods"     => "application/vnd.oasis.opendocument.spreadsheet",
+      ".odt"     => "application/vnd.oasis.opendocument.text",
+      ".ogg"     => "application/ogg",
+      ".ogv"     => "video/ogg",
+      ".p"       => "text/x-pascal",
+      ".pas"     => "text/x-pascal",
+      ".pbm"     => "image/x-portable-bitmap",
+      ".pdf"     => "application/pdf",
+      ".pem"     => "application/x-x509-ca-cert",
+      ".pgm"     => "image/x-portable-graymap",
+      ".pgp"     => "application/pgp-encrypted",
+      ".pkg"     => "application/octet-stream",
+      ".pl"      => "text/x-script.perl",
+      ".pm"      => "text/x-script.perl-module",
+      ".png"     => "image/png",
+      ".pnm"     => "image/x-portable-anymap",
+      ".ppm"     => "image/x-portable-pixmap",
+      ".pps"     => "application/vnd.ms-powerpoint",
+      ".ppt"     => "application/vnd.ms-powerpoint",
+      ".ps"      => "application/postscript",
+      ".psd"     => "image/vnd.adobe.photoshop",
+      ".py"      => "text/x-script.python",
+      ".qt"      => "video/quicktime",
+      ".ra"      => "audio/x-pn-realaudio",
+      ".rake"    => "text/x-script.ruby",
+      ".ram"     => "audio/x-pn-realaudio",
+      ".rar"     => "application/x-rar-compressed",
+      ".rb"      => "text/x-script.ruby",
+      ".rdf"     => "application/rdf+xml",
+      ".roff"    => "text/troff",
+      ".rpm"     => "application/x-redhat-package-manager",
+      ".rss"     => "application/rss+xml",
+      ".rtf"     => "application/rtf",
+      ".ru"      => "text/x-script.ruby",
+      ".s"       => "text/x-asm",
+      ".sgm"     => "text/sgml",
+      ".sgml"    => "text/sgml",
+      ".sh"      => "application/x-sh",
+      ".sig"     => "application/pgp-signature",
+      ".snd"     => "audio/basic",
+      ".so"      => "application/octet-stream",
+      ".svg"     => "image/svg+xml",
+      ".svgz"    => "image/svg+xml",
+      ".swf"     => "application/x-shockwave-flash",
+      ".t"       => "text/troff",
+      ".tar"     => "application/x-tar",
+      ".tbz"     => "application/x-bzip-compressed-tar",
+      ".tcl"     => "application/x-tcl",
+      ".tex"     => "application/x-tex",
+      ".texi"    => "application/x-texinfo",
+      ".texinfo" => "application/x-texinfo",
+      ".text"    => "text/plain",
+      ".tif"     => "image/tiff",
+      ".tiff"    => "image/tiff",
+      ".torrent" => "application/x-bittorrent",
+      ".tr"      => "text/troff",
+      ".txt"     => "text/plain",
+      ".vcf"     => "text/x-vcard",
+      ".vcs"     => "text/x-vcalendar",
+      ".vrml"    => "model/vrml",
+      ".war"     => "application/java-archive",
+      ".wav"     => "audio/x-wav",
+      ".wma"     => "audio/x-ms-wma",
+      ".wmv"     => "video/x-ms-wmv",
+      ".wmx"     => "video/x-ms-wmx",
+      ".wrl"     => "model/vrml",
+      ".wsdl"    => "application/wsdl+xml",
+      ".xbm"     => "image/x-xbitmap",
+      ".xhtml"   => "application/xhtml+xml",
+      ".xls"     => "application/vnd.ms-excel",
+      ".xml"     => "application/xml",
+      ".xpm"     => "image/x-xpixmap",
+      ".xsl"     => "application/xml",
+      ".xslt"    => "application/xslt+xml",
+      ".yaml"    => "text/yaml",
+      ".yml"     => "text/yaml",
+      ".zip"     => "application/zip",
+    }
+  end
+end

data/vendor/gems/ruby/1.8/gems/rack-1.1.0/lib/rack/mock.rb

@@ -0,0 +1,189 @@
+require 'uri'
+require 'stringio'
+require 'rack/lint'
+require 'rack/utils'
+require 'rack/response'
+
+module Rack
+  # Rack::MockRequest helps testing your Rack application without
+  # actually using HTTP.
+  #
+  # After performing a request on a URL with get/post/put/delete, it
+  # returns a MockResponse with useful helper methods for effective
+  # testing.
+  #
+  # You can pass a hash with additional configuration to the
+  # get/post/put/delete.
+  # <tt>:input</tt>:: A String or IO-like to be used as rack.input.
+  # <tt>:fatal</tt>:: Raise a FatalWarning if the app writes to rack.errors.
+  # <tt>:lint</tt>:: If true, wrap the application in a Rack::Lint.
+
+  class MockRequest
+    class FatalWarning < RuntimeError
+    end
+
+    class FatalWarner
+      def puts(warning)
+        raise FatalWarning, warning
+      end
+
+      def write(warning)
+        raise FatalWarning, warning
+      end
+
+      def flush
+      end
+
+      def string
+        ""
+      end
+    end
+
+    DEFAULT_ENV = {
+      "rack.version" => [1,1],
+      "rack.input" => StringIO.new,
+      "rack.errors" => StringIO.new,
+      "rack.multithread" => true,
+      "rack.multiprocess" => true,
+      "rack.run_once" => false,
+    }
+
+    def initialize(app)
+      @app = app
+    end
+
+    def get(uri, opts={})    request("GET", uri, opts)    end
+    def post(uri, opts={})   request("POST", uri, opts)   end
+    def put(uri, opts={})    request("PUT", uri, opts)    end
+    def delete(uri, opts={}) request("DELETE", uri, opts) end
+
+    def request(method="GET", uri="", opts={})
+      env = self.class.env_for(uri, opts.merge(:method => method))
+
+      if opts[:lint]
+        app = Rack::Lint.new(@app)
+      else
+        app = @app
+      end
+
+      errors = env["rack.errors"]
+      MockResponse.new(*(app.call(env) + [errors]))
+    end
+
+    # Return the Rack environment used for a request to +uri+.
+    def self.env_for(uri="", opts={})
+      uri = URI(uri)
+      uri.path = "/#{uri.path}" unless uri.path[0] == ?/
+
+      env = DEFAULT_ENV.dup
+
+      env["REQUEST_METHOD"] = opts[:method] ? opts[:method].to_s.upcase : "GET"
+      env["SERVER_NAME"] = uri.host || "example.org"
+      env["SERVER_PORT"] = uri.port ? uri.port.to_s : "80"
+      env["QUERY_STRING"] = uri.query.to_s
+      env["PATH_INFO"] = (!uri.path || uri.path.empty?) ? "/" : uri.path
+      env["rack.url_scheme"] = uri.scheme || "http"
+      env["HTTPS"] = env["rack.url_scheme"] == "https" ? "on" : "off"
+
+      env["SCRIPT_NAME"] = opts[:script_name] || ""
+
+      if opts[:fatal]
+        env["rack.errors"] = FatalWarner.new
+      else
+        env["rack.errors"] = StringIO.new
+      end
+
+      if params = opts[:params]
+        if env["REQUEST_METHOD"] == "GET"
+          params = Utils.parse_nested_query(params) if params.is_a?(String)
+          params.update(Utils.parse_nested_query(env["QUERY_STRING"]))
+          env["QUERY_STRING"] = Utils.build_nested_query(params)
+        elsif !opts.has_key?(:input)
+          opts["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
+          if params.is_a?(Hash)
+            if data = Utils::Multipart.build_multipart(params)
+              opts[:input] = data
+              opts["CONTENT_LENGTH"] ||= data.length.to_s
+              opts["CONTENT_TYPE"] = "multipart/form-data; boundary=#{Utils::Multipart::MULTIPART_BOUNDARY}"
+            else
+              opts[:input] = Utils.build_nested_query(params)
+            end
+          else
+            opts[:input] = params
+          end
+        end
+      end
+
+      empty_str = ""
+      empty_str.force_encoding("ASCII-8BIT") if empty_str.respond_to? :force_encoding
+      opts[:input] ||= empty_str
+      if String === opts[:input]
+        rack_input = StringIO.new(opts[:input])
+      else
+        rack_input = opts[:input]
+      end
+
+      rack_input.set_encoding(Encoding::BINARY) if rack_input.respond_to?(:set_encoding)
+      env['rack.input'] = rack_input
+
+      env["CONTENT_LENGTH"] ||= env["rack.input"].length.to_s
+
+      opts.each { |field, value|
+        env[field] = value  if String === field
+      }
+
+      env
+    end
+  end
+
+  # Rack::MockResponse provides useful helpers for testing your apps.
+  # Usually, you don't create the MockResponse on your own, but use
+  # MockRequest.
+
+  class MockResponse
+    def initialize(status, headers, body, errors=StringIO.new(""))
+      @status = status.to_i
+
+      @original_headers = headers
+      @headers = Rack::Utils::HeaderHash.new
+      headers.each { |field, values|
+        @headers[field] = values
+        @headers[field] = ""  if values.empty?
+      }
+
+      @body = ""
+      body.each { |part| @body << part }
+
+      @errors = errors.string if errors.respond_to?(:string)
+    end
+
+    # Status
+    attr_reader :status
+
+    # Headers
+    attr_reader :headers, :original_headers
+
+    def [](field)
+      headers[field]
+    end
+
+
+    # Body
+    attr_reader :body
+
+    def =~(other)
+      @body =~ other
+    end
+
+    def match(other)
+      @body.match other
+    end
+
+
+    # Errors
+    attr_accessor :errors
+
+
+    include Response::Helpers
+  end
+end

data/vendor/gems/ruby/1.8/gems/rack-1.1.0/lib/rack/nulllogger.rb

@@ -0,0 +1,18 @@
+module Rack
+  class NullLogger
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      env['rack.logger'] = self
+      @app.call(env)
+    end
+
+    def info(progname = nil, &block);  end
+    def debug(progname = nil, &block); end
+    def warn(progname = nil, &block);  end
+    def error(progname = nil, &block); end
+    def fatal(progname = nil, &block); end
+  end
+end

data/vendor/gems/ruby/1.8/gems/rack-1.1.0/lib/rack/recursive.rb

@@ -0,0 +1,57 @@
+require 'uri'
+
+module Rack
+  # Rack::ForwardRequest gets caught by Rack::Recursive and redirects
+  # the current request to the app at +url+.
+  #
+  #   raise ForwardRequest.new("/not-found")
+  #
+
+  class ForwardRequest < Exception
+    attr_reader :url, :env
+
+    def initialize(url, env={})
+      @url = URI(url)
+      @env = env
+
+      @env["PATH_INFO"] =       @url.path
+      @env["QUERY_STRING"] =    @url.query  if @url.query
+      @env["HTTP_HOST"] =       @url.host   if @url.host
+      @env["HTTP_PORT"] =       @url.port   if @url.port
+      @env["rack.url_scheme"] = @url.scheme if @url.scheme
+
+      super "forwarding to #{url}"
+    end
+  end
+
+  # Rack::Recursive allows applications called down the chain to
+  # include data from other applications (by using
+  # <tt>rack['rack.recursive.include'][...]</tt> or raise a
+  # ForwardRequest to redirect internally.
+
+  class Recursive
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      @script_name = env["SCRIPT_NAME"]
+      @app.call(env.merge('rack.recursive.include' => method(:include)))
+    rescue ForwardRequest => req
+      call(env.merge(req.env))
+    end
+
+    def include(env, path)
+      unless path.index(@script_name) == 0 && (path[@script_name.size] == ?/ ||
+                                               path[@script_name.size].nil?)
+        raise ArgumentError, "can only include below #{@script_name}, not #{path}"
+      end
+
+      env = env.merge("PATH_INFO" => path, "SCRIPT_NAME" => @script_name,
+                      "REQUEST_METHOD" => "GET",
+                      "CONTENT_LENGTH" => "0", "CONTENT_TYPE" => "",
+                      "rack.input" => StringIO.new(""))
+      @app.call(env)
+    end
+  end
+end

data/vendor/gems/ruby/1.8/gems/rack-1.1.0/lib/rack/reloader.rb

@@ -0,0 +1,109 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+#       Rack::Reloader is subject to the terms of an MIT-style license.
+#      See COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+require 'pathname'
+
+module Rack
+
+  # High performant source reloader
+  #
+  # This class acts as Rack middleware.
+  #
+  # What makes it especially suited for use in a production environment is that
+  # any file will only be checked once and there will only be made one system
+  # call stat(2).
+  #
+  # Please note that this will not reload files in the background, it does so
+  # only when actively called.
+  #
+  # It is performing a check/reload cycle at the start of every request, but
+  # also respects a cool down time, during which nothing will be done.
+  class Reloader
+    def initialize(app, cooldown = 10, backend = Stat)
+      @app = app
+      @cooldown = cooldown
+      @last = (Time.now - cooldown)
+      @cache = {}
+      @mtimes = {}
+
+      extend backend
+    end
+
+    def call(env)
+      if @cooldown and Time.now > @last + @cooldown
+        if Thread.list.size > 1
+          Thread.exclusive{ reload! }
+        else
+          reload!
+        end
+
+        @last = Time.now
+      end
+
+      @app.call(env)
+    end
+
+    def reload!(stderr = $stderr)
+      rotation do |file, mtime|
+        previous_mtime = @mtimes[file] ||= mtime
+        safe_load(file, mtime, stderr) if mtime > previous_mtime
+      end
+    end
+
+    # A safe Kernel::load, issuing the hooks depending on the results
+    def safe_load(file, mtime, stderr = $stderr)
+      load(file)
+      stderr.puts "#{self.class}: reloaded `#{file}'"
+      file
+    rescue LoadError, SyntaxError => ex
+      stderr.puts ex
+    ensure
+      @mtimes[file] = mtime
+    end
+
+    module Stat
+      def rotation
+        files = [$0, *$LOADED_FEATURES].uniq
+        paths = ['./', *$LOAD_PATH].uniq
+
+        files.map{|file|
+          next if file =~ /\.(so|bundle)$/ # cannot reload compiled files
+
+          found, stat = figure_path(file, paths)
+          next unless found && stat && mtime = stat.mtime
+
+          @cache[file] = found
+
+          yield(found, mtime)
+        }.compact
+      end
+
+      # Takes a relative or absolute +file+ name, a couple possible +paths+ that
+      # the +file+ might reside in. Returns the full path and File::Stat for the
+      # path.
+      def figure_path(file, paths)
+        found = @cache[file]
+        found = file if !found and Pathname.new(file).absolute?
+        found, stat = safe_stat(found)
+        return found, stat if found
+
+        paths.find do |possible_path|
+          path = ::File.join(possible_path, file)
+          found, stat = safe_stat(path)
+          return ::File.expand_path(found), stat if found
+        end
+
+        return false, false
+      end
+
+      def safe_stat(file)
+        return unless file
+        stat = ::File.stat(file)
+        return file, stat if stat.file?
+      rescue Errno::ENOENT, Errno::ENOTDIR
+        @cache.delete(file) and false
+      end
+    end
+  end
+end