backbone-queryparams-rails 0.0.1 → 0.0.2

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_dispatch/http/parameters.rb

@@ -1,83 +0,0 @@
-require 'active_support/core_ext/hash/keys'
-require 'active_support/core_ext/hash/indifferent_access'
-
-module ActionDispatch
-  module Http
-    module Parameters
-      # Returns both GET and POST \parameters in a single hash.
-      def parameters
-        @env["action_dispatch.request.parameters"] ||= begin
-          params = request_parameters.merge(query_parameters)
-          params.merge!(path_parameters)
-          encode_params(params).with_indifferent_access
-        end
-      end
-      alias :params :parameters
-
-      def path_parameters=(parameters) #:nodoc:
-        @symbolized_path_params = nil
-        @env.delete("action_dispatch.request.parameters")
-        @env["action_dispatch.request.path_parameters"] = parameters
-      end
-
-      # The same as <tt>path_parameters</tt> with explicitly symbolized keys.
-      def symbolized_path_parameters
-        @symbolized_path_params ||= path_parameters.symbolize_keys
-      end
-
-      # Returns a hash with the \parameters used to form the \path of the request.
-      # Returned hash keys are strings:
-      #
-      #   {'action' => 'my_action', 'controller' => 'my_controller'}
-      #
-      # See <tt>symbolized_path_parameters</tt> for symbolized keys.
-      def path_parameters
-        @env["action_dispatch.request.path_parameters"] ||= {}
-      end
-
-      def reset_parameters #:nodoc:
-        @env.delete("action_dispatch.request.parameters")
-      end
-
-    private
-
-      # TODO: Validate that the characters are UTF-8. If they aren't,
-      # you'll get a weird error down the road, but our form handling
-      # should really prevent that from happening
-      def encode_params(params)
-        return params unless "ruby".encoding_aware?
-
-        if params.is_a?(String)
-          return params.force_encoding("UTF-8").encode!
-        elsif !params.is_a?(Hash)
-          return params
-        end
-
-        params.each do |k, v|
-          case v
-          when Hash
-            encode_params(v)
-          when Array
-            v.map! {|el| encode_params(el) }
-          else
-            encode_params(v)
-          end
-        end
-      end
-
-      # Convert nested Hash to HashWithIndifferentAccess
-      def normalize_parameters(value)
-        case value
-        when Hash
-          h = {}
-          value.each { |k, v| h[k] = normalize_parameters(v) }
-          h.with_indifferent_access
-        when Array
-          value.map { |e| normalize_parameters(e) }
-        else
-          value
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_dispatch/http/rack_cache.rb

@@ -1,62 +0,0 @@
-require "rack/cache"
-require "rack/cache/context"
-require "active_support/cache"
-
-module ActionDispatch
-  class RailsMetaStore < Rack::Cache::MetaStore
-    def self.resolve(uri)
-      new
-    end
-
-    # TODO: Finally deal with the RAILS_CACHE global
-    def initialize(store = RAILS_CACHE)
-      @store = store
-    end
-
-    def read(key)
-      if data = @store.read(key)
-        Marshal.load(data)
-      else
-        []
-      end
-    end
-
-    def write(key, value)
-      @store.write(key, Marshal.dump(value))
-    end
-
-    ::Rack::Cache::MetaStore::RAILS = self
-  end
-
-  class RailsEntityStore < Rack::Cache::EntityStore
-    def self.resolve(uri)
-      new
-    end
-
-    def initialize(store = RAILS_CACHE)
-      @store = store
-    end
-
-    def exist?(key)
-      @store.exist?(key)
-    end
-
-    def open(key)
-      @store.read(key)
-    end
-
-    def read(key)
-      body = open(key)
-      body.join if body
-    end
-
-    def write(body)
-      buf = []
-      key, size = slurp(body) { |part| buf << part }
-      @store.write(key, buf)
-      [key, size]
-    end
-
-    ::Rack::Cache::EntityStore::RAILS = self
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_dispatch/http/request.rb

@@ -1,279 +0,0 @@
-require 'tempfile'
-require 'stringio'
-require 'strscan'
-
-require 'active_support/core_ext/hash/indifferent_access'
-require 'active_support/core_ext/string/access'
-require 'active_support/inflector'
-require 'action_dispatch/http/headers'
-require 'action_controller/metal/exceptions'
-
-module ActionDispatch
-  class Request < Rack::Request
-    include ActionDispatch::Http::Cache::Request
-    include ActionDispatch::Http::MimeNegotiation
-    include ActionDispatch::Http::Parameters
-    include ActionDispatch::Http::FilterParameters
-    include ActionDispatch::Http::Upload
-    include ActionDispatch::Http::URL
-
-    LOCALHOST   = [/^127\.0\.0\.\d{1,3}$/, "::1", /^0:0:0:0:0:0:0:1(%.*)?$/].freeze
-    ENV_METHODS = %w[ AUTH_TYPE GATEWAY_INTERFACE
-        PATH_TRANSLATED REMOTE_HOST
-        REMOTE_IDENT REMOTE_USER REMOTE_ADDR
-        SERVER_NAME SERVER_PROTOCOL
-
-        HTTP_ACCEPT HTTP_ACCEPT_CHARSET HTTP_ACCEPT_ENCODING
-        HTTP_ACCEPT_LANGUAGE HTTP_CACHE_CONTROL HTTP_FROM
-        HTTP_NEGOTIATE HTTP_PRAGMA ].freeze
-
-    ENV_METHODS.each do |env|
-      class_eval <<-METHOD, __FILE__, __LINE__ + 1
-        def #{env.sub(/^HTTP_/n, '').downcase}  # def accept_charset
-          @env["#{env}"]                        #   @env["HTTP_ACCEPT_CHARSET"]
-        end                                     # end
-      METHOD
-    end
-
-    def key?(key)
-      @env.key?(key)
-    end
-
-    # List of HTTP request methods from the following RFCs:
-    # Hypertext Transfer Protocol -- HTTP/1.1 (http://www.ietf.org/rfc/rfc2616.txt)
-    # HTTP Extensions for Distributed Authoring -- WEBDAV (http://www.ietf.org/rfc/rfc2518.txt)
-    # Versioning Extensions to WebDAV (http://www.ietf.org/rfc/rfc3253.txt)
-    # Ordered Collections Protocol (WebDAV) (http://www.ietf.org/rfc/rfc3648.txt)
-    # Web Distributed Authoring and Versioning (WebDAV) Access Control Protocol (http://www.ietf.org/rfc/rfc3744.txt)
-    # Web Distributed Authoring and Versioning (WebDAV) SEARCH (http://www.ietf.org/rfc/rfc5323.txt)
-    # PATCH Method for HTTP (http://www.ietf.org/rfc/rfc5789.txt)
-    RFC2616 = %w(OPTIONS GET HEAD POST PUT DELETE TRACE CONNECT)
-    RFC2518 = %w(PROPFIND PROPPATCH MKCOL COPY MOVE LOCK UNLOCK)
-    RFC3253 = %w(VERSION-CONTROL REPORT CHECKOUT CHECKIN UNCHECKOUT MKWORKSPACE UPDATE LABEL MERGE BASELINE-CONTROL MKACTIVITY)
-    RFC3648 = %w(ORDERPATCH)
-    RFC3744 = %w(ACL)
-    RFC5323 = %w(SEARCH)
-    RFC5789 = %w(PATCH)
-
-    HTTP_METHODS = RFC2616 + RFC2518 + RFC3253 + RFC3648 + RFC3744 + RFC5323 + RFC5789
-    HTTP_METHOD_LOOKUP = Hash.new { |h, m| h[m] = m.underscore.to_sym if HTTP_METHODS.include?(m) }
-
-    # Returns the HTTP \method that the application should see.
-    # In the case where the \method was overridden by a middleware
-    # (for instance, if a HEAD request was converted to a GET,
-    # or if a _method parameter was used to determine the \method
-    # the application should use), this \method returns the overridden
-    # value, not the original.
-    def request_method
-      @request_method ||= check_method(env["REQUEST_METHOD"])
-    end
-
-    # Returns a symbol form of the #request_method
-    def request_method_symbol
-      HTTP_METHOD_LOOKUP[request_method]
-    end
-
-    # Returns the original value of the environment's REQUEST_METHOD,
-    # even if it was overridden by middleware. See #request_method for
-    # more information.
-    def method
-      @method ||= check_method(env["rack.methodoverride.original_method"] || env['REQUEST_METHOD'])
-    end
-
-    # Returns a symbol form of the #method
-    def method_symbol
-      HTTP_METHOD_LOOKUP[method]
-    end
-
-    # Is this a GET (or HEAD) request?
-    # Equivalent to <tt>request.request_method_symbol == :get</tt>.
-    def get?
-      HTTP_METHOD_LOOKUP[request_method] == :get
-    end
-
-    # Is this a POST request?
-    # Equivalent to <tt>request.request_method_symbol == :post</tt>.
-    def post?
-      HTTP_METHOD_LOOKUP[request_method] == :post
-    end
-
-    # Is this a PUT request?
-    # Equivalent to <tt>request.request_method_symbol == :put</tt>.
-    def put?
-      HTTP_METHOD_LOOKUP[request_method] == :put
-    end
-
-    # Is this a DELETE request?
-    # Equivalent to <tt>request.request_method_symbol == :delete</tt>.
-    def delete?
-      HTTP_METHOD_LOOKUP[request_method] == :delete
-    end
-
-    # Is this a HEAD request?
-    # Equivalent to <tt>request.method_symbol == :head</tt>.
-    def head?
-      HTTP_METHOD_LOOKUP[method] == :head
-    end
-
-    # Provides access to the request's HTTP headers, for example:
-    #
-    #   request.headers["Content-Type"] # => "text/plain"
-    def headers
-      Http::Headers.new(@env)
-    end
-
-    def original_fullpath
-      @original_fullpath ||= (env["ORIGINAL_FULLPATH"] || fullpath)
-    end
-
-    def fullpath
-      @fullpath ||= super
-    end
-
-    def original_url
-      base_url + original_fullpath
-    end
-
-    def media_type
-      content_mime_type.to_s
-    end
-
-    # Returns the content length of the request as an integer.
-    def content_length
-      super.to_i
-    end
-
-    # Returns true if the "X-Requested-With" header contains "XMLHttpRequest"
-    # (case-insensitive). All major JavaScript libraries send this header with
-    # every Ajax request.
-    def xml_http_request?
-      @env['HTTP_X_REQUESTED_WITH'] =~ /XMLHttpRequest/i
-    end
-    alias :xhr? :xml_http_request?
-
-    def ip
-      @ip ||= super
-    end
-
-    # Originating IP address, usually set by the RemoteIp middleware.
-    def remote_ip
-      @remote_ip ||= (@env["action_dispatch.remote_ip"] || ip).to_s
-    end
-
-    # Returns the unique request id, which is based off either the X-Request-Id header that can
-    # be generated by a firewall, load balancer, or web server or by the RequestId middleware
-    # (which sets the action_dispatch.request_id environment variable).
-    #
-    # This unique ID is useful for tracing a request from end-to-end as part of logging or debugging.
-    # This relies on the rack variable set by the ActionDispatch::RequestId middleware.
-    def uuid
-      @uuid ||= env["action_dispatch.request_id"]
-    end
-
-    # Returns the lowercase name of the HTTP server software.
-    def server_software
-      (@env['SERVER_SOFTWARE'] && /^([a-zA-Z]+)/ =~ @env['SERVER_SOFTWARE']) ? $1.downcase : nil
-    end
-
-    # Read the request \body. This is useful for web services that need to
-    # work with raw requests directly.
-    def raw_post
-      unless @env.include? 'RAW_POST_DATA'
-        @env['RAW_POST_DATA'] = body.read(@env['CONTENT_LENGTH'].to_i)
-        body.rewind if body.respond_to?(:rewind)
-      end
-      @env['RAW_POST_DATA']
-    end
-
-    # The request body is an IO input stream. If the RAW_POST_DATA environment
-    # variable is already set, wrap it in a StringIO.
-    def body
-      if raw_post = @env['RAW_POST_DATA']
-        raw_post.force_encoding(Encoding::BINARY) if raw_post.respond_to?(:force_encoding)
-        StringIO.new(raw_post)
-      else
-        @env['rack.input']
-      end
-    end
-
-    def form_data?
-      FORM_DATA_MEDIA_TYPES.include?(content_mime_type.to_s)
-    end
-
-    def body_stream #:nodoc:
-      @env['rack.input']
-    end
-
-    # TODO This should be broken apart into AD::Request::Session and probably
-    # be included by the session middleware.
-    def reset_session
-      session.destroy if session && session.respond_to?(:destroy)
-      self.session = {}
-      @env['action_dispatch.request.flash_hash'] = nil
-    end
-
-    def session=(session) #:nodoc:
-      @env['rack.session'] = session
-    end
-
-    def session_options=(options)
-      @env['rack.session.options'] = options
-    end
-
-    # Override Rack's GET method to support indifferent access
-    def GET
-      @env["action_dispatch.request.query_parameters"] ||= (normalize_parameters(super) || {})
-    end
-    alias :query_parameters :GET
-
-    # Override Rack's POST method to support indifferent access
-    def POST
-      @env["action_dispatch.request.request_parameters"] ||= (normalize_parameters(super) || {})
-    end
-    alias :request_parameters :POST
-
-
-    # Returns the authorization header regardless of whether it was specified directly or through one of the
-    # proxy alternatives.
-    def authorization
-      @env['HTTP_AUTHORIZATION']   ||
-      @env['X-HTTP_AUTHORIZATION'] ||
-      @env['X_HTTP_AUTHORIZATION'] ||
-      @env['REDIRECT_X_HTTP_AUTHORIZATION']
-    end
-
-    # True if the request came from localhost, 127.0.0.1.
-    def local?
-      LOCALHOST.any? { |local_ip| local_ip === remote_addr && local_ip === remote_ip }
-    end
-
-    # Remove nils from the params hash
-    def deep_munge(hash)
-      hash.each do |k, v|
-        case v
-        when Array
-          v.grep(Hash) { |x| deep_munge(x) }
-          v.compact!
-          hash[k] = nil if v.empty?
-        when Hash
-          deep_munge(v)
-        end
-      end
-
-      hash
-    end
-
-    protected
-
-    def parse_query(qs)
-      deep_munge(super)
-    end
-
-    private
-
-    def check_method(name)
-      HTTP_METHOD_LOOKUP[name] || raise(ActionController::UnknownHttpMethod, "#{name}, accepted HTTP methods are #{HTTP_METHODS.to_sentence(:locale => :en)}")
-      name
-    end
-  end
-end

data/vendor/bundle/gems/actionpack-3.2.11/lib/action_dispatch/http/response.rb

@@ -1,206 +0,0 @@
-require 'digest/md5'
-require 'active_support/core_ext/module/delegation'
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/class/attribute_accessors'
-
-module ActionDispatch # :nodoc:
-  # Represents an HTTP response generated by a controller action. Use it to
-  # retrieve the current state of the response, or customize the response. It can
-  # either represent a real HTTP response (i.e. one that is meant to be sent
-  # back to the web browser) or a TestResponse (i.e. one that is generated
-  # from integration tests).
-  #
-  # \Response is mostly a Ruby on \Rails framework implementation detail, and
-  # should never be used directly in controllers. Controllers should use the
-  # methods defined in ActionController::Base instead. For example, if you want
-  # to set the HTTP response's content MIME type, then use
-  # ActionControllerBase#headers instead of Response#headers.
-  #
-  # Nevertheless, integration tests may want to inspect controller responses in
-  # more detail, and that's when \Response can be useful for application
-  # developers. Integration test methods such as
-  # ActionDispatch::Integration::Session#get and
-  # ActionDispatch::Integration::Session#post return objects of type
-  # TestResponse (which are of course also of type \Response).
-  #
-  # For example, the following demo integration test prints the body of the
-  # controller response to the console:
-  #
-  #  class DemoControllerTest < ActionDispatch::IntegrationTest
-  #    def test_print_root_path_to_console
-  #      get('/')
-  #      puts @response.body
-  #    end
-  #  end
-  class Response
-    attr_accessor :request, :header
-    attr_reader :status
-    attr_writer :sending_file
-
-    alias_method :headers=, :header=
-    alias_method :headers,  :header
-
-    delegate :[], :[]=, :to => :@header
-    delegate :each, :to => :@body
-
-    # Sets the HTTP response's content MIME type. For example, in the controller
-    # you could write this:
-    #
-    #  response.content_type = "text/plain"
-    #
-    # If a character set has been defined for this response (see charset=) then
-    # the character set information will also be included in the content type
-    # information.
-    attr_accessor :charset, :content_type
-
-    CONTENT_TYPE = "Content-Type".freeze
-    SET_COOKIE   = "Set-Cookie".freeze
-    LOCATION     = "Location".freeze
- 
-    cattr_accessor(:default_charset) { "utf-8" }
-
-    include Rack::Response::Helpers
-    include ActionDispatch::Http::Cache::Response
-
-    def initialize(status = 200, header = {}, body = [])
-      self.body, self.header, self.status = body, header, status
-
-      @sending_file = false
-      @blank = false
-
-      if content_type = self[CONTENT_TYPE]
-        type, charset = content_type.split(/;\s*charset=/)
-        @content_type = Mime::Type.lookup(type)
-        @charset = charset || self.class.default_charset
-      end
-
-      prepare_cache_control!
-
-      yield self if block_given?
-    end
-
-    def status=(status)
-      @status = Rack::Utils.status_code(status)
-    end
-
-    # The response code of the request
-    def response_code
-      @status
-    end
-
-    # Returns a String to ensure compatibility with Net::HTTPResponse
-    def code
-      @status.to_s
-    end
-
-    def message
-      Rack::Utils::HTTP_STATUS_CODES[@status]
-    end
-    alias_method :status_message, :message
-
-    def respond_to?(method)
-      if method.to_sym == :to_path
-        @body.respond_to?(:to_path)
-      else
-        super
-      end
-    end
-
-    def to_path
-      @body.to_path
-    end
-
-    def body
-      strings = []
-      each { |part| strings << part.to_s }
-      strings.join
-    end
-
-    EMPTY = " "
-
-    def body=(body)
-      @blank = true if body == EMPTY
-
-      # Explicitly check for strings. This is *wrong* theoretically
-      # but if we don't check this, the performance on string bodies
-      # is bad on Ruby 1.8 (because strings responds to each then).
-      @body = if body.respond_to?(:to_str) || !body.respond_to?(:each)
-        [body]
-      else
-        body
-      end
-    end
-
-    def body_parts
-      @body
-    end
-
-    def set_cookie(key, value)
-      ::Rack::Utils.set_cookie_header!(header, key, value)
-    end
-
-    def delete_cookie(key, value={})
-      ::Rack::Utils.delete_cookie_header!(header, key, value)
-    end
-
-    def location
-      headers[LOCATION]
-    end
-    alias_method :redirect_url, :location
-
-    def location=(url)
-      headers[LOCATION] = url
-    end
-
-    def close
-      @body.close if @body.respond_to?(:close)
-    end
-
-    def to_a
-      assign_default_content_type_and_charset!
-      handle_conditional_get!
-
-      @header[SET_COOKIE] = @header[SET_COOKIE].join("\n") if @header[SET_COOKIE].respond_to?(:join)
-
-      if [204, 304].include?(@status)
-        @header.delete CONTENT_TYPE
-        [@status, @header, []]
-      else
-        [@status, @header, self]
-      end
-    end
-    alias prepare! to_a
-    alias to_ary   to_a # For implicit splat on 1.9.2
-
-    # Returns the response cookies, converted to a Hash of (name => value) pairs
-    #
-    #   assert_equal 'AuthorOfNewPage', r.cookies['author']
-    def cookies
-      cookies = {}
-      if header = self[SET_COOKIE]
-        header = header.split("\n") if header.respond_to?(:to_str)
-        header.each do |cookie|
-          if pair = cookie.split(';').first
-            key, value = pair.split("=").map { |v| Rack::Utils.unescape(v) }
-            cookies[key] = value
-          end
-        end
-      end
-      cookies
-    end
-
-  private
-
-    def assign_default_content_type_and_charset!
-      return if headers[CONTENT_TYPE].present?
-
-      @content_type ||= Mime::HTML
-      @charset      ||= self.class.default_charset
-
-      type = @content_type.to_s.dup
-      type << "; charset=#{@charset}" unless @sending_file
-
-      headers[CONTENT_TYPE] = type
-    end
-  end
-end