acorn_cache 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd4a59e38e279614a289b1a8e1e6c235389f615b
+  data.tar.gz: 1558ff76e457e53fc6530c180cd5381ec050cbb9
+SHA512:
+  metadata.gz: 3014f53f2ec919dcbcae36b7c81c0ce7c686bf71499b681c6fd29d9ba76cc85ee63afce3bbff3fb8d1517964c269b959d090746cd2ce7d78f50b34e9cd317d46
+  data.tar.gz: 52bda2e31c8780828b486f6b22aebcf740d26a17a6f019e6daf9877fab93365e4115659e088cfc47429f3898528c935501ba4c24ad0ce9cc08b3edf1f4678067

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.rubocop.yml
+/notes.txt
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/*.gem

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.10.4

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Vincent J. DeVendra
+
+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 OR COPYRIGHT HOLDERS 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/README.md

@@ -0,0 +1,207 @@
+# AcornCache
+
+AcornCache is a Ruby HTTP proxy caching library that is lightweight, configurable and can be easily integrated with any Rack-based web application. AcornCache allows you to improve page load times and lighten the load on your server by allowing you to implement an in-memory cache shared by every client requesting a resource on your server.
+
+Features currently available include the following:
+
+* Honors origin server cache control directives according to RFC2616 standards unless directed otherwise.
+* Allows for easily configuring:
+    * which resources should be cached,
+    * for how long, and
+    * whether query params should be ignored
+* Allows for basic browser caching behavior modification by changing out cache control header directives.
+* Uses Redis or Memcached to store cached server responses.
+* Adds a custom header to mark responses returned from the cache (`X-Acorn-Cache: HIT`)
+
+##Getting Started
+
+####Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'acorn_cache'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself:
+
+    $ gem install acorn_cache
+
+
+AcornCache must be included in the middleware pipeline of your Rails or Rack application.
+
+With Rails, add the following config option to the appropriate environment, probably ```config/environments/production.rb```.  Note that we recommend AcornCache be positioned at the top of your middleware stack.  Replace `Rack::Sendfile` in the example if necessary.
+
+```ruby
+config.middleware.insert_before(Rack::Sendfile, Rack::AcornCache)
+```
+
+You should now see ```Rack::AcornCache``` listed at the top of your middleware pipeline when you run `rake middleware`.
+
+For non-Rails Rack apps, just include the following in your rackup (.ru) file:
+```ruby
+require 'acorn_cache'
+
+use Rack::AcornCache
+```
+
+####Setting Up Storage
+By default, AcornCache uses Redis to store server responses. You must include
+your Redis host, port, and password (if you have one set) as environment variables.
+
+```
+ACORNCACHE_REDIS_HOST="your_host_name"
+ACORNCACHE_REDIS_PORT="your_port_number"
+ACORNCACHE_REDIS_PASSWORD="your_password"
+```
+You may also choose to use memcached.  If so, set the URL (including host and
+port) and, if you have SASL authentication, username and password.
+
+```
+ACORNCACHE_MEMCACHED_URL="your_url"
+ACORNCACHE_MEMCACHED_USERNAME="your_username"
+ACORNCACHE_MEMCACHED_PASSWORD="your_password"
+```
+To switch to Memcached, add the following line to your AcornCache config:
+```ruby
+config.storage = :memcached
+```
+
+####Configuration
+AcornCache has a range of configuration options.  If you're using Rails, set them in an initializer: `config/initializers/acorn_cache.rb`
+
+Without configuration, AcornCache won't cache anything.  Two basic configuration
+patterns are possible. The most common will be to specify page rules telling
+AcornCache how long to store a resource.
+
+The config below specifies two URLs to cache and specifies the time to live, i.e., the time the resource at that location should live in AcornCache and the browser cache. With this config, AcornCache will only cache the resources at these two URLs:
+
+
+
+```ruby
+if Rails.env.production?
+  Rack::AcornCache.configure do |config|  
+    config.page_rules = {
+      "http://example.com/" => { browser_cache_ttl: 30 },
+      "http://foo.com/bar" => { acorn_cache_ttl: 100 },
+    }
+  end
+end
+```
+
+
+If you choose to do so, you can have AcornCache act as an RFC compliant
+shared proxy-cache for every resource on your server. For information concerning standard RFC caching rules,
+please refer to the Further Information section below. To operate in this mode, just set:
+
+```ruby
+config.cache_everything = true
+```
+Keep in mind that you can override standard caching behavior even when in cache everything mode by specifying a page rule.
+
+See below for all available options.
+
+## Page Rules
+Configuration options can be set for individual URLs via the
+`page-rules` config option. The value of `page-rules` must be set to a hash. The hash must have a key that is either 1) a URL string, or 2) a pattern that matches the URL of the page(s) for which you are setting the rule, and a value that specifies the caching rule(s) for the page or pages. Here's an example:
+
+```ruby
+Rack::AcornCache.configure do |config|
+  config.page_rules = {
+    { "http://foo.com" => { acorn_cache_ttl: 3600,
+                            browser_cache_ttl: 800,
+      "http://bar.com/*" => { browser_cache_ttl: 3600,
+                              ignore_query_params: true },
+      /^https+:\/\/.+\.com/ => { respect_default_header: true,
+                                 ignore_query_params: true }
+    }
+end
+```
+####Deciding Which Resources Are Cached
+Resources best suited for caching are public (not behind authentication) and don't change very often.
+AcornCache provides you with three options for defining the URLs for the resources that you want to cache:
+
+1. You can define a single URL explicitly:
+   ```ruby
+   "http://www.foobar.com/baz" => { acorn_cache_ttl: 100 }
+   ```
+
+2. You can use wildcards to identify multiple pages for a which a given set of rules applies:
+   ```ruby
+   "http://foo*.com" => { browser_cache_ttl: 86400 }
+   ```
+
+3. You can use regex pattern matching simply by using a `Regexp` object as the
+  key:
+   ```ruby
+   /^https+:\/\/.+\.com/ => { acorn_cache_ttl: 100 }
+   ```
+
+
+####Deciding How Resources Are Cached
+#####Override Existing Cache Control Headers
+Suppose you don't know or want to change the cache control headers provided by your server.  AcornCache gives you the ability to control how a resource is
+cached by both AcornCache and the browser cache simply by specifying the
+appropriate page rule settings.
+
+AcornCache provides four options, which can be set either as defaults or within
+individual page rules.
+
+1. `acorn_cache_ttl` -
+This option specifies the time a resource should live in AcornCache before
+expiring.  It works by overriding the `s-maxage` directive in the cache control
+header with the specified value. Time should be given in seconds. It also removes any directives that would
+prevent caching in a shared proxy cache, like `private` or `no-store`.
+
+2. `browser_cache_ttl` -
+This option specifies the time in seconds a resource should live in private
+browser caches before expiring.  It works by overriding the `max-age` directive
+in the cache control header with the specified value.  It also removes any
+directives that would prevent caching in a private cache, like `no-store`.
+
+3. `ignore_query_params` -
+If the query params in a request shouldn't affect the response from your server,
+you can set this option to `true` so that all requests for a URL, regardless of
+the specified params, share the same cache entry. This means that if a resource
+living at `http://foo.com` is cached with AcornCache, a request to
+`http://foo.com/?bar=baz` will respond with that cached resource without creating another
+cache entry.
+
+4. `must_revalidate` -
+When set to `true`, the content of the cache will be checked against the origin server using `ETag` or `Last-Modified` headers.  With this configuration, AcornCache will not use a cache entry without first revalidating it with the origin server.
+
+These four options can be set either as defaults or for individual page rules.
+Default settings apply to any page that AcornCache is allowed to cache unless
+they are overwritten by a page rule. For example, if your
+config looks like this...
+
+```ruby
+RackAcornCache.configure do |config|
+ config.default_acorn_cache_ttl = 30
+ config.page_rules = {
+  "http://foo.com" => { use_defaults: true }
+  "http://bar.com" => { acorn_cache_ttl: 100 }
+end
+```
+
+...then the server response returned by a request to `foo.com` will be cached in AcornCache for 30 seconds, but the server response returned by a request to `bar.com` will be cached for 100 seconds.
+
+#####Respect Existing Cache Control Headers
+AcornCache provides you with the ability to respect the cache control headers that were provided from the client or origin server.  This can be achieved by setting `respect_existing_headers: true` for a page or given set of pages. This option is useful when you don't want to cache everything but you also want to control caching behavior by ensuring that responses come from your server with the proper cache control headers.  If you choose this option, you will likely want to ensure that your response has an `s-maxage` directive, as AcornCache operates as a shared cache.
+
+## Further Information
+
+AcornCache's rules and caching guidelines strictly follow RFC 2616 standards.  [This flow chart](http://i.imgur.com/o63TJAa.jpg) details the logic and rules that AcornCache is built upon and defines its default behavior.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/acorncache/acorn-cache.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << "lib"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose
+end
+
+task :default => [:test]

data/acorn_cache.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acorn_cache/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "acorn_cache"
+  spec.version       = AcornCache::VERSION
+  spec.authors       = ["Vincent J. DeVendra", "Perry Carbone"]
+  spec.email         = ["VinceDeVendra@gmail.com", "perrycarb@gmail.com"]
+
+  spec.description       = "AcornCache is a Ruby HTTP proxy caching library that is lightweight, configurable and can be easily integrated with any Rack-based web application. AcornCache allows you to improve page load times and lighten the load on your server by allowing you to implement an in-memory cache shared by every client requesting a resource on your server."
+  spec.summary   = "A HTTP proxy caching library for Rack apps"
+  spec.homepage      = "https://github.com/acorncache/acorn-cache"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "mocha"
+  spec.add_runtime_dependency "rack", "~> 1.6"
+  spec.add_runtime_dependency "redis"
+  spec.add_runtime_dependency "dalli"
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "acorn_cache"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/acorn_cache/app_exception.rb

@@ -0,0 +1,9 @@
+class Rack::AcornCache
+  class AppException < StandardError
+    attr_reader :caught_exception
+
+    def initialize(caught_exception)
+      @caught_exception = caught_exception
+    end
+  end
+end

data/lib/acorn_cache/cache_control_header.rb

@@ -0,0 +1,48 @@
+require 'rack'
+
+class Rack::AcornCache
+  class CacheControlHeader
+    attr_accessor :max_age, :s_maxage, :no_cache, :no_store,
+                  :must_revalidate, :private, :max_fresh, :max_stale
+
+    def initialize(header_string = "")
+      return unless header_string && !header_string.empty?
+      set_directive_instance_variables!(header_string)
+    end
+
+    alias_method :max_stale?, :max_stale
+    alias_method :no_cache?, :no_cache
+    alias_method :private?, :private
+    alias_method :no_store?, :no_store
+    alias_method :must_revalidate?, :must_revalidate
+
+    def to_s
+      instance_variables.map do |ivar|
+        directive = ivar.to_s.sub("@", "").sub("_", "-")
+        value = instance_variable_get(ivar)
+        next directive if value == true
+        next unless value
+        "#{directive}=#{value}"
+      end.compact.sort.join(", ")
+    end
+
+    private
+
+    def set_directive_instance_variables!(header_string)
+      header_string.gsub(/\s+/, "").split(",").each do |directive, result|
+        k, v = directive.split("=")
+        instance_variable_set(variable_symbol(k), directive_value(v))
+      end
+    end
+
+    def variable_symbol(directive)
+      "@#{directive.gsub("-", "_")}".to_sym
+    end
+
+    def directive_value(value)
+      return value.to_i if value =~ /^[0-9]+$/
+      return true if value.nil?
+      value
+    end
+  end
+end

data/lib/acorn_cache/cache_controller.rb

@@ -0,0 +1,52 @@
+class Rack::AcornCache
+  class CacheController
+    def initialize(request, app)
+      @request = request
+      @app = app
+    end
+
+    def response
+      if request.no_cache?
+        server_response = get_response_from_server
+      else
+        cached_response = check_for_cached_response
+
+        if cached_response.must_be_revalidated?
+          request.update_conditional_headers!(cached_response)
+          server_response = get_response_from_server
+        elsif !cached_response.fresh_for_request?(request)
+          server_response = get_response_from_server
+        end
+      end
+
+      CacheMaintenance
+        .new(request.cache_key, server_response, cached_response)
+        .update_cache
+        .response
+    end
+
+    private
+
+    attr_reader :request, :app
+
+    def get_response_from_server
+      begin
+        status, headers, body = @app.call(request.env)
+      rescue => e
+        raise AppException.new(e)
+      end
+
+      server_response = ServerResponse.new(status, headers, body)
+
+      if request.page_rule?
+        server_response.update_with_page_rules!(request.page_rule)
+      else
+        server_response
+      end
+    end
+
+    def check_for_cached_response
+      CacheReader.read(request.cache_key) || NullCachedResponse.new
+    end
+  end
+end

data/lib/acorn_cache/cache_maintenance.rb

@@ -0,0 +1,27 @@
+class Rack::AcornCache
+  class CacheMaintenance
+    attr_reader :response, :cache_key, :server_response, :cached_response
+
+    def initialize(cache_key, server_response, cached_response)
+      @cache_key = cache_key
+      @server_response = server_response
+      @cached_response = cached_response
+    end
+
+    def update_cache
+      if !server_response
+        @response = cached_response.add_acorn_cache_header!
+      elsif !server_response.cacheable? && !server_response.status_304?
+        @response = server_response
+      elsif server_response.cacheable?
+        @response = server_response.cache!(cache_key)
+      elsif cached_response.matches?(server_response)
+        @response = cached_response.update_date_and_recache!(cache_key)
+      else
+        @response = server_response
+      end
+
+      self
+    end
+  end
+end

data/lib/acorn_cache/cache_reader.rb

@@ -0,0 +1,18 @@
+require 'json'
+
+class Rack::AcornCache
+  module CacheReader
+    def self.read(cache_key)
+      response = storage.get(cache_key)
+      return false unless response
+      response_hash = JSON.parse(response)
+      CachedResponse.new(response_hash)
+    end
+
+    private
+
+    def self.storage
+      Rack::AcornCache.configuration.storage
+    end
+  end
+end

data/lib/acorn_cache/cache_writer.rb

@@ -0,0 +1,13 @@
+class Rack::AcornCache
+  module CacheWriter
+    def self.write(cache_key, serialized_response)
+      storage.set(cache_key, serialized_response)
+    end
+
+    private
+
+    def self.storage
+      Rack::AcornCache.configuration.storage
+    end
+  end
+end

data/lib/acorn_cache/cached_response.rb

@@ -0,0 +1,134 @@
+require 'forwardable'
+require 'time'
+
+class Rack::AcornCache
+  class CachedResponse
+    extend Forwardable
+    def_delegators :@cache_control_header, :s_maxage, :max_age, :no_cache?, :must_revalidate?
+
+    attr_reader :body, :status, :headers, :date
+    DEFAULT_MAX_AGE = 3600
+
+    def initialize(args={})
+      @body = args["body"]
+      @status = args["status"]
+      @headers = args["headers"]
+      @cache_control_header = CacheControlHeader.new(headers["Cache-Control"])
+    end
+
+    def must_be_revalidated?
+      no_cache? || must_revalidate?
+    end
+
+    def update_date!
+      headers["Date"] = Time.now.httpdate
+    end
+
+    def serialize
+      { headers: headers, status: status, body: body }.to_json
+    end
+
+    def to_a
+      [status, headers, [body]]
+    end
+
+    def etag_header
+      headers["ETag"]
+    end
+
+    def last_modified_header
+      headers["Last-Modified"]
+    end
+
+    def update_date_and_recache!(cache_key)
+      cached_response.update_date!
+      CacheWriter.write(cache_key, cached_response.serialize)
+      self
+    end
+
+    def add_acorn_cache_header!
+      unless headers["X-Acorn-Cache"]
+        headers["X-Acorn-Cache"] = "HIT"
+      end
+      self
+    end
+
+    def matches?(server_response)
+      if etag_header
+        server_response.etag_header == etag_header
+      elsif last_modified_header
+        server_response.last_modified_header == last_modified_header
+      else
+        false
+      end
+    end
+
+    def time_to_live
+      s_maxage || max_age || (expiration_header_time - date)
+    end
+
+    alias_method :stale_time_specified?, :time_to_live
+
+    def fresh?
+      expiration_date > Time.now
+    end
+
+    def date
+      @date ||= Time.httpdate(date_header)
+    end
+
+    def expiration_date
+      if s_maxage
+        date + s_maxage
+      elsif max_age
+        date + max_age
+      elsif expiration_header
+        expiration
+      else
+        date + DEFAULT_MAX_AGE
+      end
+    end
+
+    def time_until_expiration
+      Time.now - expiration
+    end
+
+    def fresh_for_request?(request)
+      FreshnessRules.cached_response_fresh_for_request?(self, request)
+    end
+
+    private
+
+    def expiration_header_time
+      Time.httpdate(expiration_header)
+    end
+
+    def expiration_header
+      @expiration_header ||= headers["Expiration"]
+    end
+
+    def expiration
+      @expiration ||= Time.httpdate(expiration_header)
+    end
+
+    def date_header
+      headers["Date"]
+    end
+  end
+
+  class NullCachedResponse
+    def must_be_revalidated?
+      false
+    end
+
+    def matches?(server_response)
+      false
+    end
+
+    def update!; end
+
+    def fresh_for_request?(request)
+      false
+    end
+  end
+end

data/lib/acorn_cache/config.rb

@@ -0,0 +1,85 @@
+class Rack::AcornCache
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_writer :storage
+    attr_reader :page_rules
+    attr_accessor :default_acorn_cache_ttl, :default_browser_cache_ttl,
+      :cache_everything, :default_ignore_query_params, :default_must_revalidate
+
+    def initialize
+      @cache_everything = false
+      @storage = :redis
+    end
+
+    def page_rules=(user_page_rules)
+      @page_rules = user_page_rules.each_with_object({}) do |(k, v), result|
+        result[k] = build_page_rule(v)
+      end
+    end
+
+    def page_rule_for_url(url)
+      if cache_everything
+        return default_page_rule unless page_rules
+        no_page_rule_found = proc { return default_page_rule }
+      else
+        return nil unless page_rules
+        no_page_rule_found = proc { return nil }
+      end
+
+      page_rules.find(no_page_rule_found) do |k, _|
+        page_rule_key_matches_url?(k, url)
+      end.last
+    end
+
+    def storage
+      if @storage == :redis
+        Rack::AcornCache::Storage.redis
+      elsif @storage == :memcached
+        Rack::AcornCache::Storage.memcached
+      end
+    end
+
+    private
+
+    def default_page_rule
+      { acorn_cache_ttl: default_acorn_cache_ttl,
+        browser_cache_ttl: default_browser_cache_ttl,
+        ignore_query_params: default_ignore_query_params,
+        must_revalidate: default_must_revalidate }
+    end
+
+    def build_page_rule(options)
+      options[:ignore_query_params] = default_ignore_query_params
+
+      return options if options[:respect_existing_headers] || options[:must_revalidate]
+      { acorn_cache_ttl: default_acorn_cache_ttl,
+        browser_cache_ttl: default_browser_cache_ttl }.merge(options)
+    end
+
+    def page_rule_key_matches_url?(page_rule_key, url)
+      return url =~ page_rule_key if page_rule_key.is_a?(Regexp)
+      string = page_rule_key.gsub("*", ".*")
+      url =~ /^#{string}$/
+    end
+  end
+
+  #Example config setup:
+  # Rack::AcornCache.configure do |config|
+  #   config.cache_everything = true
+  #   config.default_acorn_cache_ttl = 3600
+  #   config.page_rules = {
+  #     "http://example.com/*.js" => { browser_cache_ttl: 30,
+  #                                    regex: true },
+  #     "another_url" => { acorn_cache_ttl: 100 },
+  #     "foo.com" => { respect_existing_headers: true }
+  #   }
+  # end
+end

data/lib/acorn_cache/freshness_rules.rb

@@ -0,0 +1,19 @@
+class Rack::AcornCache
+  module FreshnessRules
+    def self.cached_response_fresh_for_request?(cached_response, request)
+      return false unless cached_response
+      if cached_response.fresh?
+        if request.max_age_more_restrictive?(cached_response)
+          return cached_response.date + request.max_age >= Time.now
+        elsif request.max_fresh
+          return cached_response.expiration_date - request.max_fresh >= Time.now
+        end
+        true
+      else
+        return false unless request.max_stale?
+        return true if request.max_stale == true
+        cached_response.expiration_date + request.max_stale >= Time.now
+      end
+    end
+  end
+end

data/lib/acorn_cache/request.rb

@@ -0,0 +1,58 @@
+require 'forwardable'
+
+class Rack::AcornCache
+  class Request < Rack::Request
+    extend Forwardable
+    def_delegators :@cache_control_header, :no_cache?, :max_age, :max_fresh,
+                   :max_stale, :max_stale?
+
+    def initialize(env)
+      super
+      @cache_control_header = CacheControlHeader.new(@env["HTTP_CACHE_CONTROL"])
+    end
+
+    def update_conditional_headers!(cached_response)
+      if cached_response.etag_header
+        self.if_none_match = cached_response.etag_header
+      end
+
+      if cached_response.last_modified_header
+        self.if_modified_since = cached_response.last_modified_header
+      end
+    end
+
+    def max_age_more_restrictive?(cached_response)
+      cached_response.stale_time_specified? &&
+        max_age && max_age < cached_response.time_to_live
+    end
+
+    def cacheable?
+      get? && (config.cache_everything || page_rule?)
+    end
+
+    def page_rule
+      config.page_rule_for_url(url) if config
+    end
+
+    def cache_key
+      return base_url + path if page_rule? && page_rule[:ignore_query_params]
+      url
+    end
+
+    alias_method :page_rule?, :page_rule
+
+    private
+
+    def config
+      Rack::AcornCache.configuration
+    end
+
+    def if_none_match=(etag)
+      env["HTTP_IF_NONE_MATCH"] = etag
+    end
+
+    def if_modified_since=(last_modified)
+      env["HTTP_IF_MODIFIED_SINCE"] = last_modified
+    end
+  end
+end

data/lib/acorn_cache/server_response.rb

@@ -0,0 +1,83 @@
+require 'json'
+require 'time'
+
+class Rack::AcornCache
+  class ServerResponse < Rack::Response
+    CACHEABLE_STATUS_CODES = [200, 203, 300, 301, 302, 404, 410]
+    attr_reader :status, :headers, :body, :cache_control_header
+
+    def initialize(status, headers, body)
+      @status = status
+      @headers = headers
+      @body = body
+      @cache_control_header = CacheControlHeader.new(headers["Cache-Control"])
+    end
+
+    def update_date!
+      @headers["Date"] = Time.now.httpdate unless @headers["Date"]
+    end
+
+    def cacheable?
+      [:private?, :no_store?].none? { |directive| send(directive) } &&
+        CACHEABLE_STATUS_CODES.include?(status)
+    end
+
+    def status_304?
+      status == 304
+    end
+
+    def serialize
+      { status: status, headers: headers, body: body_string }.to_json
+    end
+
+    def body_string
+      result = ""
+      body.each { |part| result << part }
+      result
+    end
+
+    def to_a
+      [status, headers, body]
+    end
+
+    def cache!(cache_key)
+      update_date!
+      CacheWriter.write(cache_key, serialize)
+      self
+    end
+
+    def update_with_page_rules!(page_rule)
+      if page_rule[:must_revalidate]
+        self.no_cache = true
+        self.must_revalidate = true
+        self.private = nil
+        self.max_age = nil
+        self.s_maxage = nil
+        self.no_store = nil
+      end
+
+      if page_rule[:acorn_cache_ttl] || page_rule[:browser_cache_ttl]
+        self.no_cache = nil
+        self.no_store = nil
+        self.must_revalidate = nil
+      end
+
+      if page_rule[:acorn_cache_ttl]
+        self.max_age = nil
+        self.s_maxage = page_rule[:acorn_cache_ttl]
+        self.private = nil
+      end
+
+      if page_rule[:browser_cache_ttl]
+        self.max_age = page_rule[:browser_cache_ttl]
+      end
+
+      headers["Cache-Control"] = cache_control_header.to_s
+      self
+    end
+
+    def method_missing(method, *args)
+      cache_control_header.send(method, *args)
+    end
+  end
+end

data/lib/acorn_cache/storage.rb

@@ -0,0 +1,27 @@
+require 'redis'
+require 'dalli'
+
+class Rack::AcornCache
+  module Storage
+    def self.redis
+      args = { host: ENV["ACORNCACHE_REDIS_HOST"],
+               port: ENV["ACORNCACHE_REDIS_PORT"].to_i }
+      if ENV["ACORNCACHE_REDIS_PASSWORD"]
+        args.merge!(password: ENV["ACORNCACHE_REDIS_PASSWORD"])
+      end
+
+      @redis ||= Redis.new(args)
+    end
+
+    def self.memcached
+      options = {}
+
+      if ENV["ACORNCACHE_MEMCACHED_USERNAME"]
+        options = { username: ENV["ACORNCACHE_MEMCACHED_USERNAME"],
+                    password: ENV["ACORNCACHE_MEMCACHED_PASSWORD"] }
+      end
+
+      @memcached ||= Dalli::Client.new(ENV["ACORNCACHE_MEMCACHED_URL"], options)
+    end
+  end
+end

data/lib/acorn_cache/version.rb

@@ -0,0 +1,3 @@
+module AcornCache
+  VERSION = "0.1.0"
+end

data/lib/acorn_cache.rb

@@ -0,0 +1,37 @@
+require 'rack'
+
+class Rack::AcornCache
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    dup._call(env)
+  end
+
+  def _call(env)
+    request = Request.new(env)
+    return @app.call(env) unless request.cacheable?
+
+    begin
+      CacheController.new(request, @app).response.to_a
+    rescue AppException => e
+      raise e.caught_exception
+    rescue => e
+      @app.call(env)
+    end
+  end
+end
+
+require 'acorn_cache/request'
+require 'acorn_cache/cache_controller'
+require 'acorn_cache/app_exception'
+require 'acorn_cache/config'
+require 'acorn_cache/cache_control_header'
+require 'acorn_cache/cache_writer'
+require 'acorn_cache/freshness_rules'
+require 'acorn_cache/storage'
+require 'acorn_cache/cache_maintenance'
+require 'acorn_cache/server_response'
+require 'acorn_cache/cached_response'
+require 'acorn_cache/cache_reader'

metadata

@@ -0,0 +1,186 @@
+--- !ruby/object:Gem::Specification
+name: acorn_cache
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Vincent J. DeVendra
+- Perry Carbone
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: AcornCache is a Ruby HTTP proxy caching library that is lightweight,
+  configurable and can be easily integrated with any Rack-based web application. AcornCache
+  allows you to improve page load times and lighten the load on your server by allowing
+  you to implement an in-memory cache shared by every client requesting a resource
+  on your server.
+email:
+- VinceDeVendra@gmail.com
+- perrycarb@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acorn_cache.gemspec
+- bin/console
+- bin/setup
+- lib/acorn_cache.rb
+- lib/acorn_cache/app_exception.rb
+- lib/acorn_cache/cache_control_header.rb
+- lib/acorn_cache/cache_controller.rb
+- lib/acorn_cache/cache_maintenance.rb
+- lib/acorn_cache/cache_reader.rb
+- lib/acorn_cache/cache_writer.rb
+- lib/acorn_cache/cached_response.rb
+- lib/acorn_cache/config.rb
+- lib/acorn_cache/freshness_rules.rb
+- lib/acorn_cache/request.rb
+- lib/acorn_cache/server_response.rb
+- lib/acorn_cache/storage.rb
+- lib/acorn_cache/version.rb
+homepage: https://github.com/acorncache/acorn-cache
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: A HTTP proxy caching library for Rack apps
+test_files: []
+has_rdoc: