backbone-queryparams-rails 0.0.1

data/vendor/bundle/gems/rack-cache-1.2/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2008 Ryan Tomayko <http://tomayko.com/about>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/gems/rack-cache-1.2/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/vendor/bundle/gems/rack-cache-1.2/README

@@ -0,0 +1,126 @@
+Rack::Cache
+===========
+
+Rack::Cache is suitable as a quick drop-in component to enable HTTP caching for
+Rack-based applications that produce freshness (Expires, Cache-Control) and/or
+validation (Last-Modified, ETag) information:
+
+  * Standards-based (RFC 2616)
+  * Freshness/expiration based caching
+  * Validation (If-Modified-Since / If-None-Match)
+  * Vary support
+  * Cache-Control: public, private, max-age, s-maxage, must-revalidate,
+    and proxy-revalidate.
+  * Portable: 100% Ruby / works with any Rack-enabled framework
+  * Disk, memcached, and heap memory storage backends
+
+For more information about Rack::Cache features and usage, see:
+
+http://tomayko.com/src/rack-cache/
+
+Rack::Cache is not overly optimized for performance. The main goal of the
+project is to provide a portable, easy-to-configure, and standards-based
+caching solution for small to medium sized deployments. More sophisticated /
+high-performance caching systems (e.g., Varnish, Squid, httpd/mod-cache) may be
+more appropriate for large deployments with significant throughput requirements.
+
+Installation
+------------
+
+From Gem:
+
+    $ sudo gem install rack-cache
+
+With a local working copy:
+
+    $ git clone git://github.com/rtomayko/rack-cache.git
+    $ rake package && sudo rake install
+
+Basic Usage
+-----------
+
+Rack::Cache is implemented as a piece of Rack middleware and can be used with
+any Rack-based application. If your application includes a rackup (`.ru`) file
+or uses Rack::Builder to construct the application pipeline, simply require
+and use as follows:
+
+    require 'rack/cache'
+
+    use Rack::Cache,
+      :metastore   => 'file:/var/cache/rack/meta',
+      :entitystore => 'file:/var/cache/rack/body',
+      :verbose     => true
+
+    run app
+
+Assuming you've designed your backend application to take advantage of HTTP's
+caching features, no further code or configuration is required for basic
+caching.
+
+Using with Rails
+----------------
+
+Add this to your `config/environment.rb`:
+
+   config.middleware.use Rack::Cache,
+       :verbose => true,
+       :metastore   => 'file:/var/cache/rack/meta',
+       :entitystore => 'file:/var/cache/rack/body'
+
+You should now see `Rack::Cache` listed in the middleware pipeline:
+
+    rake middleware
+
+See the following for more information:
+
+    http://snippets.aktagon.com/snippets/302
+
+Using with Dalli
+----------------
+
+Dalli is a high performance memcached client for Ruby.
+More information at: https://github.com/mperham/dalli
+
+    require 'dalli'
+    require 'rack/cache'
+
+    use Rack::Cache,
+      :verbose => true,
+      :metastore   => "memcached://localhost:11211/meta",
+      :entitystore => "memcached://localhost:11211/body"
+
+    run app
+
+Links
+-----
+
+Documentation:
+    http://tomayko.com/src/rack-cache/
+
+Mailing List:
+    http://groups.google.com/group/rack-cache
+
+GitHub:
+    http://github.com/rtomayko/rack-cache/
+
+License
+-------
+
+Copyright (c) 2008 Ryan Tomayko <http://tomayko.com/about>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/gems/rack-cache-1.2/Rakefile

@@ -0,0 +1,139 @@
+require 'rake/clean'
+
+task :default => [:setup, :test]
+
+CLEAN.include %w[coverage/ doc/api tags]
+CLOBBER.include %w[dist]
+
+desc "Install gem dependencies"
+task :setup do
+  sh "bundle check >/dev/null || bundle install", :verbose => false
+end
+
+# SPECS =====================================================================
+
+desc 'Run specs with unit test style output'
+task :test => FileList['test/*_test.rb'] do |t|
+  suite = t.prerequisites
+  sh "bundle exec bacon -q -I.:lib:test #{suite.join(' ')}", :verbose => false
+end
+
+desc 'Run specs with story style output'
+task :spec => FileList['test/*_test.rb'] do |t|
+  suite = t.prerequisites
+  sh "bundle exec bacon -I.:lib:test #{suite.join(' ')}", :verbose => false
+end
+
+desc 'Generate test coverage report'
+task :rcov do
+  sh "rcov -I.:lib:test test/*_test.rb"
+end
+
+# DOC =======================================================================
+desc 'Build all documentation'
+task :doc => %w[doc:api doc:markdown]
+
+# requires the hanna gem:
+#   gem install mislav-hanna --source=http://gems.github.com
+desc 'Build API documentation (doc/api)'
+task 'doc:api' => 'doc/api/index.html'
+file 'doc/api/index.html' => FileList['lib/**/*.rb'] do |f|
+  rm_rf 'doc/api'
+  sh((<<-SH).gsub(/[\s\n]+/, ' ').strip)
+  hanna
+    --op doc/api
+    --promiscuous
+    --charset utf8
+    --fmt html
+    --inline-source
+    --line-numbers
+    --accessor option_accessor=RW
+    --main Rack::Cache
+    --title 'Rack::Cache API Documentation'
+    #{f.prerequisites.join(' ')}
+  SH
+end
+CLEAN.include 'doc/api'
+
+desc 'Build markdown documentation files'
+task 'doc:markdown'
+FileList['doc/*.markdown'].each do |source|
+  dest = "doc/#{File.basename(source, '.markdown')}.html"
+  file dest => [source, 'doc/layout.html.erb'] do |f|
+    puts "markdown: #{source} -> #{dest}" if verbose
+    require 'erb' unless defined? ERB
+    require 'rdiscount' unless defined? RDiscount
+    template = File.read(source)
+    content = Markdown.new(ERB.new(template, 0, "%<>").result(binding), :smart).to_html
+    title = content.match("<h1>(.*)</h1>")[1] rescue ''
+    layout = ERB.new(File.read("doc/layout.html.erb"), 0, "%<>")
+    output = layout.result(binding)
+    File.open(dest, 'w') { |io| io.write(output) }
+  end
+  task 'doc:markdown' => dest
+  CLEAN.include dest
+end
+
+desc 'Publish documentation'
+task 'doc:publish' => :doc do
+  sh 'rsync -avz doc/ gus@tomayko.com:/src/rack-cache'
+end
+
+desc 'Start the documentation development server (requires thin)'
+task 'doc:server' do
+  sh 'cd doc && thin --rackup server.ru --port 3035 start'
+end
+
+# PACKAGING =================================================================
+
+if defined?(Gem)
+  # load gemspec
+  $spec = eval(File.read('rack-cache.gemspec'))
+
+  def package(ext='')
+    "dist/rack-cache-#{$spec.version}" + ext
+  end
+
+  desc 'Build packages'
+  task :package => %w[.gem .tar.gz].map {|e| package(e)}
+
+  desc 'Build and install as local gem'
+  task :install => package('.gem') do
+    sh "gem install #{package('.gem')}"
+  end
+
+  directory 'dist/'
+
+  file package('.gem') => %w[dist/ rack-cache.gemspec] + $spec.files do |f|
+    sh "gem build rack-cache.gemspec"
+    mv File.basename(f.name), f.name
+  end
+
+  file package('.tar.gz') => %w[dist/] + $spec.files do |f|
+    sh "git archive --format=tar HEAD | gzip > #{f.name}"
+  end
+
+  desc 'Upload gem to gemcutter.org'
+  task 'release' => [package('.gem')] do |t|
+    sh "gem push #{package('.gem')}"
+  end
+end
+
+# GEMSPEC ===================================================================
+
+file 'rack-cache.gemspec' => FileList['{lib,test}/**','Rakefile'] do |f|
+  # read spec file and split out manifest section
+  spec = File.read(f.name)
+  parts = spec.split("  # = MANIFEST =\n")
+  fail 'bad spec' if parts.length != 3
+  # determine file list from git ls-files
+  files = `git ls-files`.
+    split("\n").sort.reject{ |file| file =~ /^\./ }.
+    map{ |file| "    #{file}" }.join("\n")
+  # piece file back together and write...
+  parts[1] = "  s.files = %w[\n#{files}\n  ]\n"
+  spec = parts.join("  # = MANIFEST =\n")
+  spec.sub!(/s.date = '.*'/, "s.date = '#{Time.now.strftime("%Y-%m-%d")}'")
+  File.open(f.name, 'w') { |io| io.write(spec) }
+  puts "updated #{f.name}"
+end

data/vendor/bundle/gems/rack-cache-1.2/TODO

@@ -0,0 +1,27 @@
+## 0.5
+
+  - Document allow_revalidate and allow_reload options.
+  - Support multiple memcache servers.
+  - Purge/invalidate everything
+  - Explicit expiration/invalidation based on response headers or via an
+    object interface passed in the rack env.
+  - Sample apps: Rack, Rails, Sinatra, Merb, etc.
+  - Move old breakers.rb configuration file into rack-contrib as a
+    middleware component.
+
+## Backlog
+
+  - Use Bacon instead of test/spec
+  - Fast path pass processing. We do a lot more than necessary just to determine
+    that the response should be passed through untouched.
+  - Invalidate at the URI of the Location or Content-Location response header
+    on POST, PUT, or DELETE that results in a redirect.
+  - Maximum size of cached entity
+  - Last-Modified factor: requests that have a Last-Modified header but no Expires
+    header have a TTL assigned based on the last modified age of the response:
+    TTL = (Age * Factor), or, 1h  = (10h * 0.1)
+  - Consider implementing ESI (http://www.w3.org/TR/esi-lang). This should
+    probably be implemented as a separate middleware component.
+  - stale-while-revalidate
+  - Serve cached copies when down (see: stale-if-error) - e.g., database
+    connection drops and the cache takes over what it can. 

data/vendor/bundle/gems/rack-cache-1.2/doc/configuration.markdown

@@ -0,0 +1,127 @@
+Configuration
+=============
+
+__Rack::Cache__ includes a configuration system that can be used to specify
+fairly sophisticated cache policy on a global or per-request basis.
+
+<a id='setopt'></a>
+
+Setting Cache Options
+---------------------
+
+Cache options can be set when the __Rack::Cache__ object is created,
+or by setting a `rack-cache.<option>` variable in __Rack__'s
+__Environment__.
+
+When the __Rack::Cache__ object is instantiated:
+
+    use Rack::Cache,
+      :verbose     => true,
+      :metastore   => 'memcached://localhost:11211/',
+      :entitystore => 'file:/var/cache/rack'
+
+Using __Rack__'s __Environment__:
+
+    env.merge!(
+      'rack-cache.verbose' => true,
+      'rack-cache.metastore' => 'memcached://localhost:11211/',
+      'rack-cache.entitystore' => 'file:/var/cache/rack'
+    )
+
+<a id='options'></a>
+
+Cache Option Reference
+----------------------
+
+Use the following options to customize __Rack::Cache__:
+
+### `verbose`
+
+Boolean specifying whether verbose trace logging is enabled. This option is
+currently enabled (`true`) by default but is likely to be disabled (`false`) in
+a future release. All log output is written to the `rack.errors` stream, which
+is typically set to `STDERR`.
+
+The `trace`, `info`, `warn`, and `error` methods can be used within the
+configuration context to write messages to the errors stream.
+
+### `default_ttl`
+
+An integer specifying the number of seconds a cached object should be considered
+"fresh" when no explicit freshness information is provided in a response.
+Explicit `Cache-Control` or `Expires` response headers always override this
+value. The `default_ttl` option defaults to `0`, meaning responses without
+explicit freshness information are considered immediately "stale" and will not
+be served from cache without validation.
+
+### `metastore`
+
+A URI specifying the __MetaStore__ implementation used to store request/response
+meta information. See the [Rack::Cache Storage Documentation](storage.html)
+for detailed information on different storage implementations.
+
+If no metastore is specified, the `heap:/` store is assumed. This implementation
+has significant draw-backs so explicit configuration is recommended.
+
+### `entitystore`
+
+A URI specifying the __EntityStore__ implementation used to store
+response bodies. See the [Rack::Cache Storage Documentation](storage.html)
+for detailed information on different storage implementations.
+
+If no entitystore is specified, the `heap:/` store is assumed. This
+implementation has significant draw-backs so explicit configuration is
+recommended.
+
+### `private_headers`
+
+An array of request header names that cause the response to be treated with
+private cache control semantics. The default value is `['Authorization', 'Cookie']`.
+If any of these headers are present in the request, the response is considered
+private and will not be cached _unless_ the response is explicitly marked public
+(e.g., `Cache-Control: public`).
+
+### `allow_reload`
+
+A boolean specifying whether reload requests sent by the client should be
+honored by the cache. When this option is enabled (`rack-cache.allow_reload`
+is `true`), requests that include a `Cache-Control: no-cache` header cause
+the cache to discard anything it has stored for the request and ask that the
+response be fully generated.
+
+Most browsers include a `Cache-Control: no-cache` header when the user performs
+a "hard refresh" (e.g., holding `Shift` while clicking the "Refresh" button).
+
+*IMPORTANT: Enabling this option globally allows all clients to break your cache.*
+
+### `allow_revalidate`
+
+A boolean specifying whether revalidate requests sent by the client should be
+honored by the cache. When this option is enabled (`rack-cache.allow_revalidate`
+is `true`), requests that include a `Cache-Control: max-age=0` header cause the
+cache to assume its copy of the response is stale, resulting in a conditional
+GET / validation request to be sent to the server.
+
+Most browsers include a `Cache-Control: max-age=0` header when the user performs
+a refresh (e.g., clicking the "Refresh" button).
+
+*IMPORTANT: Enabling this option globally allows all clients to break your cache.*
+
+### `cache_key`
+
+A custom cache key generator, which can be anything that responds to :call.
+By default, this is the `Rack::Cache::Key` class, but you can implement your own
+generator. A cache key generator gets passed a `Rack::Request` object and generates
+the appropriate cache key.
+
+The `Rack::Cache::Key` class by default returns the fully qualified url of the request.
+
+In addition to setting the generator to an object, you can just pass a block instead, 
+which will act as the cache key generator:
+	
+	set :cache_key do |request|
+		request.fullpath.replace(/\//, '-')
+	end
+	
+For more options see the [Rack::Request documentation](http://rack.rubyforge.org/doc/classes/Rack/Request.html)
+	

data/vendor/bundle/gems/rack-cache-1.2/doc/faq.markdown

@@ -0,0 +1,148 @@
+Frequently Asked Questions
+==========================
+
+<p class='intro'>
+<strong>NOTE:</strong> This is a work in progress. Please send questions, comments, or
+suggestions to <a href="mailto:r@tomayko.com">r@tomayko.com</a>.
+</p>
+
+General
+-------
+
+
+<a class='hash' id='rails' href='#rails'>#</a>
+
+### Q: Can I use Rack::Cache with Rails?
+
+Rack::Cache can be used with Rails 2.3 or above. Documentation and a
+sample application is forthcoming; in the mean time, see
+[this example of using Rack::Cache with Rails 2.3](http://snippets.aktagon.com/snippets/302-How-to-setup-and-use-Rack-Cache-with-Rails-2-3-0-RC-1).
+
+<a class='hash' id='why-not-squid' href='#why-not-squid'>#</a>
+
+### Q: Why Rack::Cache? Why not Squid, Varnish, Perlbol, etc.?
+
+__Rack::Cache__ is often easier to setup as part of your existing Ruby
+application than a separate caching system. __Rack::Cache__ runs entirely inside
+your backend application processes - no separate / external process is required.
+This lets __Rack::Cache__ scale down to development environments and simple
+deployments very easily while not sacrificing the benefits of a standards-based
+approach to caching.
+
+
+<a class='hash' id='why-not-rails' href='#why-not-rails'>#</a>
+
+### Q: Why Rack::Cache? Why not use Rails/Merb/FrameworkX's caching system?
+
+__Rack::Cache__ takes a standards-based approach to caching that provides some
+benefits over framework-integrated systems.  It uses standard HTTP headers
+(`Expires`, `Cache-Control`, `Etag`, `Last-Modified`, etc.) to determine
+what/when to cache. Designing applications to support these standard HTTP
+mechanisms gives the benefit of being able to switch to a different HTTP
+cache implementation in the future.
+
+In addition, using a standards-based approach to caching creates a clear
+separation between application and caching logic. The application need only
+specify a basic set of information about the response and all decisions
+regarding how and when to cache is moved into the caching layer.
+
+
+<a class='hash' id='scale' href='#scale'>#</a>
+
+### Q: Will Rack::Cache make my app scale?
+
+No. Your design is the only thing that can make your app scale.
+
+Also, __Rack::Cache__ is not overly optimized for performance. The main goal of
+the project is to provide a portable, easy-to-configure, and standards-based
+caching solution for small to medium sized deployments. More sophisticated /
+performant caching systems (e.g., [Varnish][v], [Squid][s],
+[httpd/mod-cache][h]) may be more appropriate for large deployments with
+crazy-land throughput requirements.
+
+[v]: http://varnish.projects.linpro.no/
+[s]: http://www.squid-cache.org/
+[h]: http://httpd.apache.org/docs/2.0/mod/mod_cache.html
+
+
+Features
+--------
+
+
+<a class='hash' id='validation' href='#validation'>#</a>
+
+### Q: Does Rack::Cache support validation?
+
+Yes. Both freshness and validation-based caching is supported. A response
+will be cached if it has a freshness lifetime (e.g., `Expires` or
+`Cache-Control: max-age=N` headers) and/or includes a validator (e.g.,
+`Last-Modified` or `ETag` headers). When the cache hits and the response is
+fresh, it's delivered immediately without talking to the backend application;
+when the cache is stale, the cached response is validated using a conditional
+GET request.
+
+
+<a class='hash' id='fragments' href='#fragments'>#</a>
+
+### Q: Does Rack::Cache support fragment caching?
+
+Not really. __Rack::Cache__ deals with entire responses and doesn't know
+anything about how your application constructs them.
+
+However, something like [ESI](http://www.w3.org/TR/esi-lang) may be implemented
+in the future (likely as a separate Rack middleware component that could be
+situated upstream from Rack::Cache), which would allow applications to compose
+responses based on several "fragment resources". Each fragment would have its
+own cache policy.
+
+
+<a class='hash' id='manual-purge' href='#manual-purge'>#</a>
+
+### Q: How do I manually purge or expire a cached entry?
+
+Although planned, there is currently no mechanism for manually purging
+an entry stored in the cache.
+
+Note that using an `Expires` or `Cache-Control: max-age=N` header and relying on
+manual purge to invalidate cached entry can often be implemented more simply
+using efficient validation based caching (`Last-Modified`, `Etag`). Many web
+frameworks are based entirely on manual purge and do not support validation at
+the cache level.
+
+
+<a class='hash' id='force-pass' href='#force-pass'>#</a>
+
+### Q: How do I bypass rack-cache on a per-request basis?
+
+Set the `rack-cache.force-pass` variable in the rack environment to `true`.
+
+
+<a class='hash' id='efficient-validation' href='#efficient-validation'>#</a>
+
+### Q: What does "Efficient Validation" mean?
+
+It means that your application performs only the processing necessary to
+determine if a response is valid before sending a `304 Not Modified` in response
+to a conditional GET request.  Many applications that perform validation do so
+only after the entire response has been generated, which provides bandwidth
+savings but results in no CPU/IO savings.  Implementing validation efficiently
+can increase backend application throughput significantly when fronted by a
+validating caching system (like __Rack::Cache__).
+
+[Here's an example Rack application](http://gist.github.com/9395) that performs
+efficient validation.
+
+
+<a class='hash' id='orly' href='#orly'>#</a>
+
+### Q: Did you just make that up?
+
+Yes.
+
+
+<a class='hash' id='https' href='#https'>#</a>
+
+### Q: Can I do HTTPS with Rack::Cache?
+
+Sure. HTTPS is typically managed by a front-end web server so this isn't really
+relevant to Rack::Cache.