backbone-queryparams-rails 0.0.1 → 0.0.2

data/vendor/bundle/gems/rack-1.4.4/lib/rack/response.rb

@@ -1,156 +0,0 @@
-require 'rack/request'
-require 'rack/utils'
-require 'time'
-
-module Rack
-  # Rack::Response provides a convenient interface to create a Rack
-  # response.
-  #
-  # It allows setting of headers and cookies, and provides useful
-  # defaults (a OK response containing HTML).
-  #
-  # You can use Response#write to iteratively generate your response,
-  # but note that this is buffered by Rack::Response until you call
-  # +finish+.  +finish+ however can take a block inside which calls to
-  # +write+ are synchronous with the Rack response.
-  #
-  # Your application's +call+ should end returning Response#finish.
-
-  class Response
-    attr_accessor :length
-
-    def initialize(body=[], status=200, header={})
-      @status = status.to_i
-      @header = Utils::HeaderHash.new("Content-Type" => "text/html").
-                                      merge(header)
-
-      @chunked = "chunked" == @header['Transfer-Encoding']
-      @writer  = lambda { |x| @body << x }
-      @block   = nil
-      @length  = 0
-
-      @body = []
-
-      if body.respond_to? :to_str
-        write body.to_str
-      elsif body.respond_to?(:each)
-        body.each { |part|
-          write part.to_s
-        }
-      else
-        raise TypeError, "stringable or iterable required"
-      end
-
-      yield self  if block_given?
-    end
-
-    attr_reader :header
-    attr_accessor :status, :body
-
-    def [](key)
-      header[key]
-    end
-
-    def []=(key, value)
-      header[key] = value
-    end
-
-    def set_cookie(key, value)
-      Utils.set_cookie_header!(header, key, value)
-    end
-
-    def delete_cookie(key, value={})
-      Utils.delete_cookie_header!(header, key, value)
-    end
-
-    def redirect(target, status=302)
-      self.status = status
-      self["Location"] = target
-    end
-
-    def finish(&block)
-      @block = block
-
-      if [204, 205, 304].include?(status.to_i)
-        header.delete "Content-Type"
-        header.delete "Content-Length"
-        close
-        [status.to_i, header, []]
-      else
-        [status.to_i, header, BodyProxy.new(self){}]
-      end
-    end
-    alias to_a finish           # For *response
-    alias to_ary finish         # For implicit-splat on Ruby 1.9.2
-
-    def each(&callback)
-      @body.each(&callback)
-      @writer = callback
-      @block.call(self)  if @block
-    end
-
-    # Append to body and update Content-Length.
-    #
-    # NOTE: Do not mix #write and direct #body access!
-    #
-    def write(str)
-      s = str.to_s
-      @length += Rack::Utils.bytesize(s) unless @chunked
-      @writer.call s
-
-      header["Content-Length"] = @length.to_s unless @chunked
-      str
-    end
-
-    def close
-      body.close if body.respond_to?(:close)
-    end
-
-    def empty?
-      @block == nil && @body.empty?
-    end
-
-    alias headers header
-
-    module Helpers
-      def invalid?;            status < 100 || status >= 600;        end
-
-      def informational?;      status >= 100 && status < 200;        end
-      def successful?;         status >= 200 && status < 300;        end
-      def redirection?;        status >= 300 && status < 400;        end
-      def client_error?;       status >= 400 && status < 500;        end
-      def server_error?;       status >= 500 && status < 600;        end
-
-      def ok?;                 status == 200;                        end
-      def bad_request?;        status == 400;                        end
-      def forbidden?;          status == 403;                        end
-      def not_found?;          status == 404;                        end
-      def method_not_allowed?; status == 405;                        end
-      def unprocessable?;      status == 422;                        end
-
-      def redirect?;           [301, 302, 303, 307].include? status; end
-
-      # Headers
-      attr_reader :headers, :original_headers
-
-      def include?(header)
-        !!headers[header]
-      end
-
-      def content_type
-        headers["Content-Type"]
-      end
-
-      def content_length
-        cl = headers["Content-Length"]
-        cl ? cl.to_i : cl
-      end
-
-      def location
-        headers["Location"]
-      end
-    end
-
-    include Helpers
-  end
-end

data/vendor/bundle/gems/rack-1.4.4/lib/rack/rewindable_input.rb

@@ -1,104 +0,0 @@
-# -*- encoding: binary -*-
-require 'tempfile'
-require 'rack/utils'
-
-module Rack
-  # Class which can make any IO object rewindable, including non-rewindable ones. It does
-  # this by buffering the data into a tempfile, which is rewindable.
-  #
-  # rack.input is required to be rewindable, so if your input stream IO is non-rewindable
-  # by nature (e.g. a pipe or a socket) then you can wrap it in an object of this class
-  # to easily make it rewindable.
-  #
-  # Don't forget to call #close when you're done. This frees up temporary resources that
-  # RewindableInput uses, though it does *not* close the original IO object.
-  class RewindableInput
-    def initialize(io)
-      @io = io
-      @rewindable_io = nil
-      @unlinked = false
-    end
-
-    def gets
-      make_rewindable unless @rewindable_io
-      @rewindable_io.gets
-    end
-
-    def read(*args)
-      make_rewindable unless @rewindable_io
-      @rewindable_io.read(*args)
-    end
-
-    def each(&block)
-      make_rewindable unless @rewindable_io
-      @rewindable_io.each(&block)
-    end
-
-    def rewind
-      make_rewindable unless @rewindable_io
-      @rewindable_io.rewind
-    end
-
-    # Closes this RewindableInput object without closing the originally
-    # wrapped IO oject. Cleans up any temporary resources that this RewindableInput
-    # has created.
-    #
-    # This method may be called multiple times. It does nothing on subsequent calls.
-    def close
-      if @rewindable_io
-        if @unlinked
-          @rewindable_io.close
-        else
-          @rewindable_io.close!
-        end
-        @rewindable_io = nil
-      end
-    end
-
-    private
-
-    # Ruby's Tempfile class has a bug. Subclass it and fix it.
-    class Tempfile < ::Tempfile
-      def _close
-        @tmpfile.close if @tmpfile
-        @data[1] = nil if @data
-        @tmpfile = nil
-      end
-    end
-
-    def make_rewindable
-      # Buffer all data into a tempfile. Since this tempfile is private to this
-      # RewindableInput object, we chmod it so that nobody else can read or write
-      # it. On POSIX filesystems we also unlink the file so that it doesn't
-      # even have a file entry on the filesystem anymore, though we can still
-      # access it because we have the file handle open.
-      @rewindable_io = Tempfile.new('RackRewindableInput')
-      @rewindable_io.chmod(0000)
-      @rewindable_io.set_encoding(Encoding::BINARY) if @rewindable_io.respond_to?(:set_encoding)
-      @rewindable_io.binmode
-      if filesystem_has_posix_semantics?
-        # Use ::File.unlink as 1.9.1 Tempfile has a bug where unlink closes the file!
-        ::File.unlink @rewindable_io.path
-        raise 'Unlink failed. IO closed.' if @rewindable_io.closed?
-        @unlinked = true
-      end
-
-      buffer = ""
-      while @io.read(1024 * 4, buffer)
-        entire_buffer_written_out = false
-        while !entire_buffer_written_out
-          written = @rewindable_io.write(buffer)
-          entire_buffer_written_out = written == Rack::Utils.bytesize(buffer)
-          if !entire_buffer_written_out
-            buffer.slice!(0 .. written - 1)
-          end
-        end
-      end
-      @rewindable_io.rewind
-    end
-
-    def filesystem_has_posix_semantics?
-      RUBY_PLATFORM !~ /(mswin|mingw|cygwin|java)/
-    end
-  end
-end

data/vendor/bundle/gems/rack-1.4.4/lib/rack/runtime.rb

@@ -1,27 +0,0 @@
-module Rack
-  # Sets an "X-Runtime" response header, indicating the response
-  # time of the request, in seconds
-  #
-  # You can put it right before the application to see the processing
-  # time, or before all the other middlewares to include time for them,
-  # too.
-  class Runtime
-    def initialize(app, name = nil)
-      @app = app
-      @header_name = "X-Runtime"
-      @header_name << "-#{name}" if name
-    end
-
-    def call(env)
-      start_time = Time.now
-      status, headers, body = @app.call(env)
-      request_time = Time.now - start_time
-
-      if !headers.has_key?(@header_name)
-        headers[@header_name] = "%0.6f" % request_time
-      end
-
-      [status, headers, body]
-    end
-  end
-end

data/vendor/bundle/gems/rack-1.4.4/lib/rack/sendfile.rb

@@ -1,141 +0,0 @@
-require 'rack/file'
-
-module Rack
-
-  # = Sendfile
-  #
-  # The Sendfile middleware intercepts responses whose body is being
-  # served from a file and replaces it with a server specific X-Sendfile
-  # header. The web server is then responsible for writing the file contents
-  # to the client. This can dramatically reduce the amount of work required
-  # by the Ruby backend and takes advantage of the web server's optimized file
-  # delivery code.
-  #
-  # In order to take advantage of this middleware, the response body must
-  # respond to +to_path+ and the request must include an X-Sendfile-Type
-  # header. Rack::File and other components implement +to_path+ so there's
-  # rarely anything you need to do in your application. The X-Sendfile-Type
-  # header is typically set in your web servers configuration. The following
-  # sections attempt to document
-  #
-  # === Nginx
-  #
-  # Nginx supports the X-Accel-Redirect header. This is similar to X-Sendfile
-  # but requires parts of the filesystem to be mapped into a private URL
-  # hierarachy.
-  #
-  # The following example shows the Nginx configuration required to create
-  # a private "/files/" area, enable X-Accel-Redirect, and pass the special
-  # X-Sendfile-Type and X-Accel-Mapping headers to the backend:
-  #
-  #   location ~ /files/(.*) {
-  #     internal;
-  #     alias /var/www/$1;
-  #   }
-  #
-  #   location / {
-  #     proxy_redirect     off;
-  #
-  #     proxy_set_header   Host                $host;
-  #     proxy_set_header   X-Real-IP           $remote_addr;
-  #     proxy_set_header   X-Forwarded-For     $proxy_add_x_forwarded_for;
-  #
-  #     proxy_set_header   X-Sendfile-Type     X-Accel-Redirect;
-  #     proxy_set_header   X-Accel-Mapping     /var/www/=/files/;
-  #
-  #     proxy_pass         http://127.0.0.1:8080/;
-  #   }
-  #
-  # Note that the X-Sendfile-Type header must be set exactly as shown above.
-  # The X-Accel-Mapping header should specify the location on the file system,
-  # followed by an equals sign (=), followed name of the private URL pattern
-  # that it maps to. The middleware performs a simple substitution on the
-  # resulting path.
-  #
-  # See Also: http://wiki.codemongers.com/NginxXSendfile
-  #
-  # === lighttpd
-  #
-  # Lighttpd has supported some variation of the X-Sendfile header for some
-  # time, although only recent version support X-Sendfile in a reverse proxy
-  # configuration.
-  #
-  #   $HTTP["host"] == "example.com" {
-  #      proxy-core.protocol = "http"
-  #      proxy-core.balancer = "round-robin"
-  #      proxy-core.backends = (
-  #        "127.0.0.1:8000",
-  #        "127.0.0.1:8001",
-  #        ...
-  #      )
-  #
-  #      proxy-core.allow-x-sendfile = "enable"
-  #      proxy-core.rewrite-request = (
-  #        "X-Sendfile-Type" => (".*" => "X-Sendfile")
-  #      )
-  #    }
-  #
-  # See Also: http://redmine.lighttpd.net/wiki/lighttpd/Docs:ModProxyCore
-  #
-  # === Apache
-  #
-  # X-Sendfile is supported under Apache 2.x using a separate module:
-  #
-  # https://tn123.org/mod_xsendfile/
-  #
-  # Once the module is compiled and installed, you can enable it using
-  # XSendFile config directive:
-  #
-  #   RequestHeader Set X-Sendfile-Type X-Sendfile
-  #   ProxyPassReverse / http://localhost:8001/
-  #   XSendFile on
-
-  class Sendfile
-    F = ::File
-
-    def initialize(app, variation=nil)
-      @app = app
-      @variation = variation
-    end
-
-    def call(env)
-      status, headers, body = @app.call(env)
-      if body.respond_to?(:to_path)
-        case type = variation(env)
-        when 'X-Accel-Redirect'
-          path = F.expand_path(body.to_path)
-          if url = map_accel_path(env, path)
-            headers['Content-Length'] = '0'
-            headers[type] = url
-            body = []
-          else
-            env['rack.errors'].puts "X-Accel-Mapping header missing"
-          end
-        when 'X-Sendfile', 'X-Lighttpd-Send-File'
-          path = F.expand_path(body.to_path)
-          headers['Content-Length'] = '0'
-          headers[type] = path
-          body = []
-        when '', nil
-        else
-          env['rack.errors'].puts "Unknown x-sendfile variation: '#{variation}'.\n"
-        end
-      end
-      [status, headers, body]
-    end
-
-    private
-    def variation(env)
-      @variation ||
-        env['sendfile.type'] ||
-        env['HTTP_X_SENDFILE_TYPE']
-    end
-
-    def map_accel_path(env, file)
-      if mapping = env['HTTP_X_ACCEL_MAPPING']
-        internal, external = mapping.split('=', 2).map{ |p| p.strip }
-        file.sub(/^#{internal}/i, external)
-      end
-    end
-  end
-end

data/vendor/bundle/gems/rack-1.4.4/lib/rack/server.rb

@@ -1,349 +0,0 @@
-require 'optparse'
-
-module Rack
-  class Server
-    class Options
-      def parse!(args)
-        options = {}
-        opt_parser = OptionParser.new("", 24, '  ') do |opts|
-          opts.banner = "Usage: rackup [ruby options] [rack options] [rackup config]"
-
-          opts.separator ""
-          opts.separator "Ruby options:"
-
-          lineno = 1
-          opts.on("-e", "--eval LINE", "evaluate a LINE of code") { |line|
-            eval line, TOPLEVEL_BINDING, "-e", lineno
-            lineno += 1
-          }
-
-          opts.on("-d", "--debug", "set debugging flags (set $DEBUG to true)") {
-            options[:debug] = true
-          }
-          opts.on("-w", "--warn", "turn warnings on for your script") {
-            options[:warn] = true
-          }
-
-          opts.on("-I", "--include PATH",
-                  "specify $LOAD_PATH (may be used more than once)") { |path|
-            (options[:include] ||= []).concat(path.split(":"))
-          }
-
-          opts.on("-r", "--require LIBRARY",
-                  "require the library, before executing your script") { |library|
-            options[:require] = library
-          }
-
-          opts.separator ""
-          opts.separator "Rack options:"
-          opts.on("-s", "--server SERVER", "serve using SERVER (webrick/mongrel)") { |s|
-            options[:server] = s
-          }
-
-          opts.on("-o", "--host HOST", "listen on HOST (default: 0.0.0.0)") { |host|
-            options[:Host] = host
-          }
-
-          opts.on("-p", "--port PORT", "use PORT (default: 9292)") { |port|
-            options[:Port] = port
-          }
-
-          opts.on("-O", "--option NAME[=VALUE]", "pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} -s SERVER -h' to get a list of options for SERVER") { |name|
-            name, value = name.split('=', 2)
-            value = true if value.nil?
-            options[name.to_sym] = value
-          }
-
-          opts.on("-E", "--env ENVIRONMENT", "use ENVIRONMENT for defaults (default: development)") { |e|
-            options[:environment] = e
-          }
-
-          opts.on("-D", "--daemonize", "run daemonized in the background") { |d|
-            options[:daemonize] = d ? true : false
-          }
-
-          opts.on("-P", "--pid FILE", "file to store PID (default: rack.pid)") { |f|
-            options[:pid] = ::File.expand_path(f)
-          }
-
-          opts.separator ""
-          opts.separator "Common options:"
-
-          opts.on_tail("-h", "-?", "--help", "Show this message") do
-            puts opts
-            puts handler_opts(options)
-
-            exit
-          end
-
-          opts.on_tail("--version", "Show version") do
-            puts "Rack #{Rack.version} (Release: #{Rack.release})"
-            exit
-          end
-        end
-
-        begin
-          opt_parser.parse! args
-        rescue OptionParser::InvalidOption => e
-          warn e.message
-          abort opt_parser.to_s
-        end
-
-        options[:config] = args.last if args.last
-        options
-      end
-
-      def handler_opts(options)
-        begin
-          info = []
-          server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
-          if server && server.respond_to?(:valid_options)
-            info << ""
-            info << "Server-specific options for #{server.name}:"
-
-            has_options = false
-            server.valid_options.each do |name, description|
-              next if name.to_s.match(/^(Host|Port)[^a-zA-Z]/) # ignore handler's host and port options, we do our own.
-              info << "  -O %-21s %s" % [name, description]
-              has_options = true
-            end
-            return "" if !has_options
-          end
-          info.join("\n")
-        rescue NameError
-          return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
-        end
-      end
-    end
-
-    # Start a new rack server (like running rackup). This will parse ARGV and
-    # provide standard ARGV rackup options, defaulting to load 'config.ru'.
-    #
-    # Providing an options hash will prevent ARGV parsing and will not include
-    # any default options.
-    #
-    # This method can be used to very easily launch a CGI application, for
-    # example:
-    #
-    #  Rack::Server.start(
-    #    :app => lambda do |e|
-    #      [200, {'Content-Type' => 'text/html'}, ['hello world']]
-    #    end,
-    #    :server => 'cgi'
-    #  )
-    #
-    # Further options available here are documented on Rack::Server#initialize
-    def self.start(options = nil)
-      new(options).start
-    end
-
-    attr_writer :options
-
-    # Options may include:
-    # * :app
-    #     a rack application to run (overrides :config)
-    # * :config
-    #     a rackup configuration file path to load (.ru)
-    # * :environment
-    #     this selects the middleware that will be wrapped around
-    #     your application. Default options available are:
-    #       - development: CommonLogger, ShowExceptions, and Lint
-    #       - deployment: CommonLogger
-    #       - none: no extra middleware
-    #     note: when the server is a cgi server, CommonLogger is not included.
-    # * :server
-    #     choose a specific Rack::Handler, e.g. cgi, fcgi, webrick
-    # * :daemonize
-    #     if true, the server will daemonize itself (fork, detach, etc)
-    # * :pid
-    #     path to write a pid file after daemonize
-    # * :Host
-    #     the host address to bind to (used by supporting Rack::Handler)
-    # * :Port
-    #     the port to bind to (used by supporting Rack::Handler)
-    # * :AccessLog
-    #     webrick acess log options (or supporting Rack::Handler)
-    # * :debug
-    #     turn on debug output ($DEBUG = true)
-    # * :warn
-    #     turn on warnings ($-w = true)
-    # * :include
-    #     add given paths to $LOAD_PATH
-    # * :require
-    #     require the given libraries
-    def initialize(options = nil)
-      @options = options
-      @app = options[:app] if options && options[:app]
-    end
-
-    def options
-      @options ||= parse_options(ARGV)
-    end
-
-    def default_options
-      {
-        :environment => ENV['RACK_ENV'] || "development",
-        :pid         => nil,
-        :Port        => 9292,
-        :Host        => "0.0.0.0",
-        :AccessLog   => [],
-        :config      => "config.ru"
-      }
-    end
-
-    def app
-      @app ||= begin
-        if !::File.exist? options[:config]
-          abort "configuration #{options[:config]} not found"
-        end
-
-        app, options = Rack::Builder.parse_file(self.options[:config], opt_parser)
-        self.options.merge! options
-        app
-      end
-    end
-
-    def self.logging_middleware
-      lambda { |server|
-        server.server.name =~ /CGI/ ? nil : [Rack::CommonLogger, $stderr]
-      }
-    end
-
-    def self.middleware
-      @middleware ||= begin
-        m = Hash.new {|h,k| h[k] = []}
-        m["deployment"].concat [
-          [Rack::ContentLength],
-          [Rack::Chunked],
-          logging_middleware
-        ]
-        m["development"].concat m["deployment"] + [[Rack::ShowExceptions], [Rack::Lint]]
-        m
-      end
-    end
-
-    def middleware
-      self.class.middleware
-    end
-
-    def start &blk
-      if options[:warn]
-        $-w = true
-      end
-
-      if includes = options[:include]
-        $LOAD_PATH.unshift(*includes)
-      end
-
-      if library = options[:require]
-        require library
-      end
-
-      if options[:debug]
-        $DEBUG = true
-        require 'pp'
-        p options[:server]
-        pp wrapped_app
-        pp app
-      end
-
-      check_pid! if options[:pid]
-
-      # Touch the wrapped app, so that the config.ru is loaded before
-      # daemonization (i.e. before chdir, etc).
-      wrapped_app
-
-      daemonize_app if options[:daemonize]
-
-      write_pid if options[:pid]
-
-      trap(:INT) do
-        if server.respond_to?(:shutdown)
-          server.shutdown
-        else
-          exit
-        end
-      end
-
-      server.run wrapped_app, options, &blk
-    end
-
-    def server
-      @_server ||= Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
-    end
-
-    private
-      def parse_options(args)
-        options = default_options
-
-        # Don't evaluate CGI ISINDEX parameters.
-        # http://www.meb.uni-bonn.de/docs/cgi/cl.html
-        args.clear if ENV.include?("REQUEST_METHOD")
-
-        options.merge! opt_parser.parse!(args)
-        options[:config] = ::File.expand_path(options[:config])
-        ENV["RACK_ENV"] = options[:environment]
-        options
-      end
-
-      def opt_parser
-        Options.new
-      end
-
-      def build_app(app)
-        middleware[options[:environment]].reverse_each do |middleware|
-          middleware = middleware.call(self) if middleware.respond_to?(:call)
-          next unless middleware
-          klass = middleware.shift
-          app = klass.new(app, *middleware)
-        end
-        app
-      end
-
-      def wrapped_app
-        @wrapped_app ||= build_app app
-      end
-
-      def daemonize_app
-        if RUBY_VERSION < "1.9"
-          exit if fork
-          Process.setsid
-          exit if fork
-          Dir.chdir "/"
-          STDIN.reopen "/dev/null"
-          STDOUT.reopen "/dev/null", "a"
-          STDERR.reopen "/dev/null", "a"
-        else
-          Process.daemon
-        end
-      end
-
-      def write_pid
-        ::File.open(options[:pid], 'w'){ |f| f.write("#{Process.pid}") }
-        at_exit { ::File.delete(options[:pid]) if ::File.exist?(options[:pid]) }
-      end
-
-      def check_pid!
-        case pidfile_process_status
-        when :running, :not_owned
-          $stderr.puts "A server is already running. Check #{options[:pid]}."
-          exit(1)
-        when :dead
-          ::File.delete(options[:pid])
-        end
-      end
-
-      def pidfile_process_status
-        return :exited unless ::File.exist?(options[:pid])
-
-        pid = ::File.read(options[:pid]).to_i
-        Process.kill(0, pid)
-        :running
-      rescue Errno::ESRCH
-        :dead
-      rescue Errno::EPERM
-        :not_owned
-      end
-
-  end
-end