challah 0.5.0 → 0.5.1

data/vendor/bundle/gems/rack-cache-1.1/lib/rack/cache/context.rb

@@ -1,275 +0,0 @@
-require 'rack/cache/options'
-require 'rack/cache/request'
-require 'rack/cache/response'
-require 'rack/cache/storage'
-
-module Rack::Cache
-  # Implements Rack's middleware interface and provides the context for all
-  # cache logic, including the core logic engine.
-  class Context
-    include Rack::Cache::Options
-
-    # Array of trace Symbols
-    attr_reader :trace
-
-    # The Rack application object immediately downstream.
-    attr_reader :backend
-
-    def initialize(backend, options={})
-      @backend = backend
-      @trace = []
-
-      initialize_options options
-      yield self if block_given?
-
-      @private_header_keys =
-        private_headers.map { |name| "HTTP_#{name.upcase.tr('-', '_')}" }
-    end
-
-    # The configured MetaStore instance. Changing the rack-cache.metastore
-    # value effects the result of this method immediately.
-    def metastore
-      uri = options['rack-cache.metastore']
-      storage.resolve_metastore_uri(uri)
-    end
-
-    # The configured EntityStore instance. Changing the rack-cache.entitystore
-    # value effects the result of this method immediately.
-    def entitystore
-      uri = options['rack-cache.entitystore']
-      storage.resolve_entitystore_uri(uri)
-    end
-
-    # The Rack call interface. The receiver acts as a prototype and runs
-    # each request in a dup object unless the +rack.run_once+ variable is
-    # set in the environment.
-    def call(env)
-      if env['rack.run_once']
-        call! env
-      else
-        clone.call! env
-      end
-    end
-
-    # The real Rack call interface. The caching logic is performed within
-    # the context of the receiver.
-    def call!(env)
-      @trace = []
-      @default_options.each { |k,v| env[k] ||= v }
-      @env = env
-      @request = Request.new(@env.dup.freeze)
-
-      response =
-        if @request.get? || @request.head?
-          if !@env['HTTP_EXPECT'] && !@env['rack-cache.force-pass']
-            lookup
-          else
-            pass
-          end
-        else
-          invalidate
-        end
-
-      # log trace and set X-Rack-Cache tracing header
-      trace = @trace.join(', ')
-      response.headers['X-Rack-Cache'] = trace
-
-      # write log message to rack.errors
-      if verbose?
-        message = "cache: [%s %s] %s\n" %
-          [@request.request_method, @request.fullpath, trace]
-        @env['rack.errors'].write(message)
-      end
-
-      # tidy up response a bit
-      response.not_modified! if not_modified?(response)
-      if @request.head?
-        response.body.close if response.body.respond_to?(:close)
-        response.body = []
-      end
-      response.to_a
-    end
-
-  private
-
-    # Record that an event took place.
-    def record(event)
-      @trace << event
-    end
-
-    # Does the request include authorization or other sensitive information
-    # that should cause the response to be considered private by default?
-    # Private responses are not stored in the cache.
-    def private_request?
-      @private_header_keys.any? { |key| @env.key?(key) }
-    end
-
-    # Determine if the #response validators (ETag, Last-Modified) matches
-    # a conditional value specified in #request.
-    def not_modified?(response)
-      last_modified = @request.env['HTTP_IF_MODIFIED_SINCE']
-      if etags = @request.env['HTTP_IF_NONE_MATCH']
-        etags = etags.split(/\s*,\s*/)
-        (etags.include?(response.etag) || etags.include?('*')) && (!last_modified || response.last_modified == last_modified)
-      elsif last_modified
-        response.last_modified == last_modified
-      end
-    end
-
-    # Whether the cache entry is "fresh enough" to satisfy the request.
-    def fresh_enough?(entry)
-      if entry.fresh?
-        if allow_revalidate? && max_age = @request.cache_control.max_age
-          max_age > 0 && max_age >= entry.age
-        else
-          true
-        end
-      end
-    end
-
-    # Delegate the request to the backend and create the response.
-    def forward
-      Response.new(*backend.call(@env))
-    end
-
-    # The request is sent to the backend, and the backend's response is sent
-    # to the client, but is not entered into the cache.
-    def pass
-      record :pass
-      forward
-    end
-
-    # Invalidate POST, PUT, DELETE and all methods not understood by this cache
-    # See RFC2616 13.10
-    def invalidate
-      metastore.invalidate(@request, entitystore)
-    rescue Exception => e
-      log_error(e)
-      pass
-    else
-      record :invalidate
-      pass
-    end
-
-    # Try to serve the response from cache. When a matching cache entry is
-    # found and is fresh, use it as the response without forwarding any
-    # request to the backend. When a matching cache entry is found but is
-    # stale, attempt to #validate the entry with the backend using conditional
-    # GET. When no matching cache entry is found, trigger #miss processing.
-    def lookup
-      if @request.no_cache? && allow_reload?
-        record :reload
-        fetch
-      else
-        begin
-          entry = metastore.lookup(@request, entitystore)
-        rescue Exception => e
-          log_error(e)
-          return pass
-        end
-        if entry
-          if fresh_enough?(entry)
-            record :fresh
-            entry.headers['Age'] = entry.age.to_s
-            entry
-          else
-            record :stale
-            validate(entry)
-          end
-        else
-          record :miss
-          fetch
-        end
-      end
-    end
-
-    # Validate that the cache entry is fresh. The original request is used
-    # as a template for a conditional GET request with the backend.
-    def validate(entry)
-      # send no head requests because we want content
-      @env['REQUEST_METHOD'] = 'GET'
-
-      # add our cached last-modified validator to the environment
-      @env['HTTP_IF_MODIFIED_SINCE'] = entry.last_modified
-
-      # Add our cached etag validator to the environment.
-      # We keep the etags from the client to handle the case when the client
-      # has a different private valid entry which is not cached here.
-      cached_etags = entry.etag.to_s.split(/\s*,\s*/)
-      request_etags = @request.env['HTTP_IF_NONE_MATCH'].to_s.split(/\s*,\s*/)
-      etags = (cached_etags + request_etags).uniq
-      @env['HTTP_IF_NONE_MATCH'] = etags.empty? ? nil : etags.join(', ')
-
-      response = forward
-
-      if response.status == 304
-        record :valid
-
-        # Check if the response validated which is not cached here
-        etag = response.headers['ETag']
-        return response if etag && request_etags.include?(etag) && !cached_etags.include?(etag)
-
-        entry = entry.dup
-        entry.headers.delete('Date')
-        %w[Date Expires Cache-Control ETag Last-Modified].each do |name|
-          next unless value = response.headers[name]
-          entry.headers[name] = value
-        end
-
-        # even though it's empty, be sure to close the response body from upstream
-        # because middleware use close to signal end of response
-        response.body.close if response.body.respond_to?(:close)
-
-        response = entry
-      else
-        record :invalid
-      end
-
-      store(response) if response.cacheable?
-
-      response
-    end
-
-    # The cache missed or a reload is required. Forward the request to the
-    # backend and determine whether the response should be stored. This allows
-    # conditional / validation requests through to the backend but performs no
-    # caching of the response when the backend returns a 304.
-    def fetch
-      # send no head requests because we want content
-      @env['REQUEST_METHOD'] = 'GET'
-
-      response = forward
-
-      # Mark the response as explicitly private if any of the private
-      # request headers are present and the response was not explicitly
-      # declared public.
-      if private_request? && !response.cache_control.public?
-        response.private = true
-      elsif default_ttl > 0 && response.ttl.nil? && !response.cache_control.must_revalidate?
-        # assign a default TTL for the cache entry if none was specified in
-        # the response; the must-revalidate cache control directive disables
-        # default ttl assigment.
-        response.ttl = default_ttl
-      end
-
-      store(response) if response.cacheable?
-
-      response
-    end
-
-    # Write the response to the cache.
-    def store(response)
-      metastore.store(@request, response, entitystore)
-      response.headers['Age'] = response.age.to_s
-    rescue Exception => e
-      log_error(e)
-      nil
-    else
-      record :store
-    end
-
-    def log_error(exception)
-      @env['rack.errors'].write("cache error: #{exception.message}\n#{exception.backtrace.join("\n")}\n")
-    end
-  end
-end

data/vendor/bundle/gems/rack-cache-1.1/lib/rack/cache/metastore.rb

@@ -1,418 +0,0 @@
-require 'fileutils'
-require 'digest/sha1'
-require 'rack/utils'
-require 'rack/cache/key'
-
-module Rack::Cache
-
-  # The MetaStore is responsible for storing meta information about a
-  # request/response pair keyed by the request's URL.
-  #
-  # The meta store keeps a list of request/response pairs for each canonical
-  # request URL. A request/response pair is a two element Array of the form:
-  #   [request, response]
-  #
-  # The +request+ element is a Hash of Rack environment keys. Only protocol
-  # keys (i.e., those that start with "HTTP_") are stored. The +response+
-  # element is a Hash of cached HTTP response headers for the paired request.
-  #
-  # The MetaStore class is abstract and should not be instanstiated
-  # directly. Concrete subclasses should implement the protected #read,
-  # #write, and #purge methods. Care has been taken to keep these low-level
-  # methods dumb and straight-forward to implement.
-  class MetaStore
-
-    # Locate a cached response for the request provided. Returns a
-    # Rack::Cache::Response object if the cache hits or nil if no cache entry
-    # was found.
-    def lookup(request, entity_store)
-      key = cache_key(request)
-      entries = read(key)
-
-      # bail out if we have nothing cached
-      return nil if entries.empty?
-
-      # find a cached entry that matches the request.
-      env = request.env
-      match = entries.detect{|req,res| requests_match?(res['Vary'], env, req)}
-      return nil if match.nil?
-
-      req, res = match
-      if body = entity_store.open(res['X-Content-Digest'])
-        restore_response(res, body)
-      else
-        # TODO the metastore referenced an entity that doesn't exist in
-        # the entitystore. we definitely want to return nil but we should
-        # also purge the entry from the meta-store when this is detected.
-      end
-    end
-
-    # Write a cache entry to the store under the given key. Existing
-    # entries are read and any that match the response are removed.
-    # This method calls #write with the new list of cache entries.
-    def store(request, response, entity_store)
-      key = cache_key(request)
-      stored_env = persist_request(request)
-
-      # write the response body to the entity store if this is the
-      # original response.
-      if response.headers['X-Content-Digest'].nil?
-        if request.env['rack-cache.use_native_ttl'] && response.fresh?
-          digest, size = entity_store.write(response.body, response.ttl)
-        else
-          digest, size = entity_store.write(response.body)
-        end
-        response.headers['X-Content-Digest'] = digest
-        response.headers['Content-Length'] = size.to_s unless response.headers['Transfer-Encoding']
-        response.body = entity_store.open(digest)
-      end
-
-      # read existing cache entries, remove non-varying, and add this one to
-      # the list
-      vary = response.vary
-      entries =
-        read(key).reject do |env,res|
-          (vary == res['Vary']) &&
-            requests_match?(vary, env, stored_env)
-        end
-
-      headers = persist_response(response)
-      headers.delete 'Age'
-
-      entries.unshift [stored_env, headers]
-      write key, entries
-      key
-    end
-
-    # Generate a cache key for the request.
-    def cache_key(request)
-      keygen = request.env['rack-cache.cache_key'] || Key
-      keygen.call(request)
-    end
-
-    # Invalidate all cache entries that match the request.
-    def invalidate(request, entity_store)
-      modified = false
-      key = cache_key(request)
-      entries =
-        read(key).map do |req, res|
-          response = restore_response(res)
-          if response.fresh?
-            response.expire!
-            modified = true
-            [req, persist_response(response)]
-          else
-            [req, res]
-          end
-        end
-      write key, entries if modified
-    end
-
-  private
-
-    # Extract the environment Hash from +request+ while making any
-    # necessary modifications in preparation for persistence. The Hash
-    # returned must be marshalable.
-    def persist_request(request)
-      env = request.env.dup
-      env.reject! { |key,val| key =~ /[^0-9A-Z_]/ || !val.respond_to?(:to_str) }
-      env
-    end
-
-    # Converts a stored response hash into a Response object. The caller
-    # is responsible for loading and passing the body if needed.
-    def restore_response(hash, body=nil)
-      status = hash.delete('X-Status').to_i
-      Rack::Cache::Response.new(status, hash, body)
-    end
-
-    def persist_response(response)
-      hash = response.headers.to_hash
-      hash['X-Status'] = response.status.to_s
-      hash
-    end
-
-    # Determine whether the two environment hashes are non-varying based on
-    # the vary response header value provided.
-    def requests_match?(vary, env1, env2)
-      return true if vary.nil? || vary == ''
-      vary.split(/[\s,]+/).all? do |header|
-        key = "HTTP_#{header.upcase.tr('-', '_')}"
-        env1[key] == env2[key]
-      end
-    end
-
-  protected
-    # Locate all cached request/response pairs that match the specified
-    # URL key. The result must be an Array of all cached request/response
-    # pairs. An empty Array must be returned if nothing is cached for
-    # the specified key.
-    def read(key)
-      raise NotImplemented
-    end
-
-    # Store an Array of request/response pairs for the given key. Concrete
-    # implementations should not attempt to filter or concatenate the
-    # list in any way.
-    def write(key, negotiations)
-      raise NotImplemented
-    end
-
-    # Remove all cached entries at the key specified. No error is raised
-    # when the key does not exist.
-    def purge(key)
-      raise NotImplemented
-    end
-
-  private
-    # Generate a SHA1 hex digest for the specified string. This is a
-    # simple utility method for meta store implementations.
-    def hexdigest(data)
-      Digest::SHA1.hexdigest(data)
-    end
-
-  public
-    # Concrete MetaStore implementation that uses a simple Hash to store
-    # request/response pairs on the heap.
-    class Heap < MetaStore
-      def initialize(hash={})
-        @hash = hash
-      end
-
-      def read(key)
-        if data = @hash[key]
-          Marshal.load(data)
-        else
-          []
-        end
-      end
-
-      def write(key, entries)
-        @hash[key] = Marshal.dump(entries)
-      end
-
-      def purge(key)
-        @hash.delete(key)
-        nil
-      end
-
-      def to_hash
-        @hash
-      end
-
-      def self.resolve(uri)
-        new
-      end
-    end
-
-    HEAP = Heap
-    MEM = HEAP
-
-    # Concrete MetaStore implementation that stores request/response
-    # pairs on disk.
-    class Disk < MetaStore
-      attr_reader :root
-
-      def initialize(root="/tmp/rack-cache/meta-#{ARGV[0]}")
-        @root = File.expand_path(root)
-        FileUtils.mkdir_p(root, :mode => 0755)
-      end
-
-      def read(key)
-        path = key_path(key)
-        File.open(path, 'rb') { |io| Marshal.load(io) }
-      rescue Errno::ENOENT, IOError
-        []
-      end
-
-      def write(key, entries)
-        tries = 0
-        begin
-          path = key_path(key)
-          File.open(path, 'wb') { |io| Marshal.dump(entries, io, -1) }
-        rescue Errno::ENOENT, IOError
-          Dir.mkdir(File.dirname(path), 0755)
-          retry if (tries += 1) == 1
-        end
-      end
-
-      def purge(key)
-        path = key_path(key)
-        File.unlink(path)
-        nil
-      rescue Errno::ENOENT, IOError
-        nil
-      end
-
-    private
-      def key_path(key)
-        File.join(root, spread(hexdigest(key)))
-      end
-
-      def spread(sha, n=2)
-        sha = sha.dup
-        sha[n,0] = '/'
-        sha
-      end
-
-    public
-      def self.resolve(uri)
-        path = File.expand_path(uri.opaque || uri.path)
-        new path
-      end
-
-    end
-
-    DISK = Disk
-    FILE = Disk
-
-    # Stores request/response pairs in memcached. Keys are not stored
-    # directly since memcached has a 250-byte limit on key names. Instead,
-    # the SHA1 hexdigest of the key is used.
-    class MemCacheBase < MetaStore
-      extend Rack::Utils
-
-      # The MemCache object used to communicated with the memcached
-      # daemon.
-      attr_reader :cache
-
-      # Create MemCache store for the given URI. The URI must specify
-      # a host and may specify a port, namespace, and options:
-      #
-      # memcached://example.com:11211/namespace?opt1=val1&opt2=val2
-      #
-      # Query parameter names and values are documented with the memcached
-      # library: http://tinyurl.com/4upqnd
-      def self.resolve(uri)
-        if uri.respond_to?(:scheme)
-          server = "#{uri.host}:#{uri.port || '11211'}"
-          options = parse_query(uri.query)
-          options.keys.each do |key|
-            value =
-              case value = options.delete(key)
-              when 'true' ; true
-              when 'false' ; false
-              else value.to_sym
-              end
-            options[key.to_sym] = value
-          end
-
-          options[:namespace] = uri.path.to_s.sub(/^\//, '')
-
-          new server, options
-        else
-          # if the object provided is not a URI, pass it straight through
-          # to the underlying implementation.
-          new uri
-        end
-      end
-    end
-
-    class Dalli < MemCacheBase
-      def initialize(server="localhost:11211", options={})
-        @cache =
-          if server.respond_to?(:stats)
-            server
-          else
-            require 'dalli'
-            ::Dalli::Client.new(server, options)
-          end
-      end
-
-      def read(key)
-        key = hexdigest(key)
-        cache.get(key) || []
-      end
-
-      def write(key, entries)
-        key = hexdigest(key)
-        cache.set(key, entries)
-      end
-
-      def purge(key)
-        cache.delete(hexdigest(key))
-        nil
-      end
-    end
-
-    class MemCached < MemCacheBase
-      # The Memcached instance used to communicated with the memcached
-      # daemon.
-      attr_reader :cache
-
-      def initialize(server="localhost:11211", options={})
-        options[:prefix_key] ||= options.delete(:namespace) if options.key?(:namespace)
-        @cache =
-          if server.respond_to?(:stats)
-            server
-          else
-            require 'memcached'
-            Memcached.new(server, options)
-          end
-      end
-
-      def read(key)
-        key = hexdigest(key)
-        cache.get(key)
-      rescue Memcached::NotFound
-        []
-      end
-
-      def write(key, entries)
-        key = hexdigest(key)
-        cache.set(key, entries)
-      end
-
-      def purge(key)
-        key = hexdigest(key)
-        cache.delete(key)
-        nil
-      rescue Memcached::NotFound
-        nil
-      end
-    end
-
-    MEMCACHE =
-      if defined?(::Memcached)
-        MemCached
-      else
-        Dalli
-      end
-    MEMCACHED = MEMCACHE
-
-    class GAEStore < MetaStore
-      attr_reader :cache
-
-      def initialize(options = {})
-        require 'rack/cache/appengine'
-        @cache = Rack::Cache::AppEngine::MemCache.new(options)
-      end
-
-      def read(key)
-        key = hexdigest(key)
-        cache.get(key) || []
-      end
-
-      def write(key, entries)
-        key = hexdigest(key)
-        cache.put(key, entries)
-      end
-
-      def purge(key)
-        key = hexdigest(key)
-        cache.delete(key)
-        nil
-      end
-
-      def self.resolve(uri)
-        self.new(:namespace => uri.host)
-      end
-
-    end
-
-    GAECACHE = GAEStore
-    GAE = GAEStore
-
-  end
-
-end