garner 0.1.1

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2012 Art.sy, Frank Macreery, Daniel Doubrovkine & Contributors
+
+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,114 @@
+Garner [![Build Status](https://secure.travis-ci.org/dblock/garner.png)](http://travis-ci.org/dblock/garner)
+======
+
+Garner is a practical Rack-based cache implementation for RESTful APIs with support for HTTP 304 Not Modified based on time and ETags, model and instance binding and hierarchical invalidation. Garner is currently targeted at [Grape](https://github.com/intridea/grape), other systems may need some work.
+
+Usage
+-----
+
+Add Garner to Gemfile with `gem "garner"` and run `bundle install`. Include the Garner mixin into your API. Currently Grape is supported out of the box. It's also recommended to prevent clients from caching dynamic data by default using the `Garner::Middleware::Cache::Bust` middleware. See below for a detailed explanation.
+
+```ruby
+class API < Grape::API
+  use Garner::Middleware::Cache::Bust
+  helpers Garner::Mixins::Grape::Cache
+end
+```
+
+To cache a value, invoke `cache` from within your API. Without any parameters it generates a key based on the source code location, request parameters and path, and stores the value in the cache configured as `Garner.config.cache`. The cache is automatically `Rails.cache` when mounted in Rails and an instance of `ActiveSupport::Cache::MemoryStore` otherwise.
+
+``` ruby
+get "/" do
+  cache do
+    { :counter => 42 }
+  end
+end
+```
+
+To enable support for the date-based `If-Modified-Since` and the ETag-based `If-None-Match`, use `cache_or_304`. If the data hasn't changed, the API will return `304 Not Modified` without a cache miss. For example, if the inside of a cached block is a database query, it will not be executed the second time. This is possible because Garner stores an entry for every cache binding with the last-modified timestamp and ETag.
+
+``` ruby
+get "/" do
+  cache_or_304 do
+    { :counter => 42 }
+  end
+end
+```
+
+The cached value can also be bound to other models. For example, if a user has an address that may or may not change when the user is saved, you will want the cached address to be invalidated every time the user record changes.
+
+``` ruby
+get "/me/address" do
+  cache_or_304(:bind => [ User, current_user.id ]) do
+    current_user.address
+  end
+end
+```
+
+Binding Strategies
+------------------
+
+The binding parameter can be an object, class, array of objects, or array of classes on which to bind the validity of the cached result contained in the subsequent block. If no bind argument is specified, the subsequent block result will remain valid until it expires due to natural causes (e.g., passage of default memcached expiry, or memcached overflow). Here are some examples of how to use the bind option.
+
+* `bind: { klass: Widget, object: { id: params[:id] } }` will cause the subsequent block result to be invalidated on any change to the `Widget` object whose `id` attribute equals `params[:id]`.
+* `bind: { klass: User, object: { id: current_user.id } }` will cause the subsequent block result to be invalidated on any change to the `User` object whose `id` attribute equals `current_user.id`. This is one way to bind a cache result to any change in the current user.
+* `bind: { klass: Widget }` will cause the subsequent block result to be invalidated on any change to any object of class `Widget`. This is the appropriate strategy for index paths like `/widgets`.
+* `bind: [{ klass: Widget }, { klass: User, object: { id: current_user.id } }]` will cause the subsequent block result to be invalidated on any change to either the current user, or any object of class `Widget`.
+
+Bind supports some nice shorthands.
+
+* `bind: [Widget]` is shorthand for `bind: { klass: Widget }`
+* `bind: [Widget, params[:id]]` is shorthand for `bind: { klass: Widget, object: { id: params[:slug] } }`
+* `bind: [User, { id: current_user.id }]` is shorthand for `bind: { klass: User, object: { id: current_user.id } }`
+* `bind: [[Widget], [User, { id: current_user.id }]]` is shorthand for `bind: [{ klass: Widget }, { klass: User, object: { id: current_user.id } }]`
+
+Invalidation
+------------
+
+You must take care of data invalidation on save. Garner currently includes a mixin with support for [Mongoid](https://github.com/mongoid/mongoid). Extend `Mongoid::Document` as follows (eg. in `config/initializers/mongoid_document.rb`).
+
+``` ruby
+module Mongoid
+  module Document
+    include Garner::Mixins::Mongoid::Document
+  end
+end
+```
+
+Please contribute other invalidation mixins.
+
+Configuration
+-------------
+
+By default `Garner` will use an instance of `ActiveSupport::Cache::MemoryStore` in a non-Rails and `Rails.cache` in a Rails environment. You can configure it to use any other cache store.
+
+``` ruby
+Garner.configure do |config|
+  config.cache = ActiveSupport::Cache::FileStore.new
+end
+```
+
+Preventing Clients from Caching Dynamic Data
+--------------------------------------------
+
+Generally, dynamic data cannot have a well-defined expiration time. Therefore, we must tell the client not to cache it. This can be accomplished using the `Garner::Middleware::Cache::Bust` middleware, executed after any API call. The middleware adds a `Cache-Control` and an `Expires` header.
+
+```
+Cache-Control: private, max-age=0, must-revalidate
+Expires: Fri, 01 Jan 1990 00:00:00 GMT
+```
+
+The `private` option of the `Cache-Control` header instructs the client that it is allowed to store data in a private cache (unnecessary, but is known to work around overzealous cache implementations), `max-age` that it must check with the server every time it needs this data and `must-revalidate` prevents gateways from returning a response if your API server is unreachable. An additional `Expires` header will make double-sure the entire request expires immediately.
+
+Contributing
+------------
+
+Fork the project. Make your feature addition or bug fix with tests. Send a pull request. Bonus points for topic branches.
+
+Copyright and License
+---------------------
+
+MIT License, see [LICENSE](https://github.com/dblock/garner/blob/master/LICENSE.md) for details.
+
+(c) 2012 [Art.sy Inc.](http://artsy.github.com), [Frank Macreery](https://github.com/macreery), [Daniel Doubrovkine](https://github.com/dblock) and [Contributors](https://github.com/dblock/garner/blob/master/CHANGELOG.md)
+

data/lib/garner/cache/object_identity.rb

@@ -0,0 +1,214 @@
+module Garner
+  module Cache
+    #
+    # A cache that uses an object identity binding strategy.
+    #
+    # Allows some flexibility in how caller binds objects in cache.
+    # The binding can be an object, class, array of objects, or array of classes
+    # on which to bind the validity of the cached result contained in the subsequent
+    # block.
+    #
+    # @example `bind: { klass: Widget, object: { id: params[:id] } }` will cause a cached instance to be
+    # invalidated on any change to the `Widget` object whose slug attribute equals `params[:id]`
+    #
+    # @example `bind: { klass: User, object: { id: current_user.id } }` will cause a cached instance to be
+    # invalidated on any change to the `User` object whose id attribute equals current_user.id.
+    # This is one way to bind a cache result to any change in the current user.
+    #
+    # @example `bind: { klass: Widget }` will cause the cached instance to be invalidated on any change to
+    # any object of class Widget. This is the appropriate strategy for index paths like /widgets.
+    #
+    # @example `bind: [{ klass: Widget }, { klass: User, object: { id: current_user.id } }]` will cause a
+    # cached instance to be invalidated on any change to either the current user, or any object of class Widget.
+    #
+    # @example `bind: [Artwork]` is shorthand for `bind: { klass: Artwork }`
+    #
+    # @example `bind: [Artwork, params[:id]]` is shorthand for `bind: { klass: Artwork, object: { id: params[:id] } }`
+    #
+    # @example `bind: [User, { id: current_user.id }] is shorthand for `bind: { klass: User, object: { id: current_user.id } }`
+    #
+    # @example `bind: [[Artwork], [User, { id: current_user.id }]]` is shorthand for
+    # `bind: [{ klass: Artwork }, { klass: User, object: { id: current_user.id } }]`
+    #
+    module ObjectIdentity
+      
+      IDENTITY_FIELDS = [ :id ]
+
+      KEY_STRATEGIES = [
+        Garner::Strategies::Keys::Caller,
+        Garner::Strategies::Keys::Version,
+        Garner::Strategies::Keys::RequestPath,
+        Garner::Strategies::Keys::RequestGet
+      ]
+      
+      CACHE_STRATEGIES = [
+        Garner::Strategies::Cache::Expiration
+      ]
+      
+      class << self
+
+        # cache the result of an executable block
+        def cache(binding = nil, context = {})
+          # apply cache strategies
+          cache_options = cache_options(context)
+          CACHE_STRATEGIES.each do |strategy|
+            cache_options = strategy.apply(cache_options)
+          end
+          key = key(binding, key_context(context))
+          result = Garner.config.cache.fetch(key, cache_options) do
+            object = yield
+            reset_cache_metadata(key, object)
+            object
+          end
+          Garner.config.cache.delete(key) unless result
+          result
+        end
+                
+        # invalidate an object that has been cached
+        def invalidate(* args)
+          options = index(*args)
+          reset_key_prefix_for(options[:klass], options[:object])
+          reset_key_prefix_for(options[:klass]) if options[:object]
+        end
+        
+        # metadata for cached objects:
+        #   :etag - Unique hash of object content
+        #   :last_modified - Timestamp of last modification event
+        def cache_metadata(binding, context = {})
+          key = key(binding, key_context(context))
+          Garner.config.cache.read(meta(key))
+        end
+        
+        private
+
+          # applied cache options
+          def cache_options(context)
+            context[:cache_options] || {}
+          end
+        
+          # applied key context
+          def key_context(context)
+            new_context = {}
+            context ||= {}
+            KEY_STRATEGIES.each do |strategy|
+              new_context = strategy.apply(new_context, context)
+            end
+            new_context
+          end
+
+          def reset_key_prefix_for(klass, object = nil)
+             Garner.config.cache.write(
+               index_string_for(klass, object),
+               new_key_prefix_for(klass, object),
+               {}
+             )
+           end
+
+          def reset_cache_metadata(key, object)
+            return unless object
+            metadata = {
+              :etag => Garner::Objects::ETag.from(object),
+              :last_modified => Time.now
+            }
+            meta_key = meta(key)
+            Garner.config.cache.write(meta_key, metadata)
+          end
+  
+          def new_key_prefix_for(klass, object = nil)
+            Digest::MD5.hexdigest("#{klass}/#{object || "*"}:#{new_key_postfix}")
+          end
+           
+          # Generate a key in the Klass/id format.
+          # @example Widget/id=1,Gadget/slug=forty-two,Fudget/*
+          def key(binding = nil, context = {})
+            bound = binding && binding[:bind] ? standardize(binding[:bind]) : {}
+            bound = (bound.is_a?(Array) ? bound : [ bound ]).compact
+            bound.collect { |el|
+              if el[:object] && ! IDENTITY_FIELDS.map { |id| el[:object][id] }.compact.any?
+                raise ArgumentError, ":bind object arguments (#{bound}) can only be keyed by #{IDENTITY_FIELDS.join(", ")}"
+              end
+              find_or_create_key_prefix_for(el[:klass], el[:object])
+            }.join(",") + ":" +
+            Digest::MD5.hexdigest(
+              KEY_STRATEGIES.map { |strategy| context[strategy.field] }.compact.join("\n")
+            )
+          end
+        
+          # Generate an index key from args
+          def index(* args)
+            case args[0]
+            when Hash
+              args[0]
+            when Class
+              case args[1]
+              when Hash
+                { :klass => args[0], :object => args[1] }
+              when NilClass
+                { :klass => args[0] }
+              else
+                { :klass => args[0], :object => { IDENTITY_FIELDS.first => args[1] } }
+              end
+            else
+              raise ArgumentError, "invalid args, must be (klass, identifier) or hash (#{args})"
+            end
+          end
+               
+          def find_or_create_key_prefix_for(klass, object = nil)
+            Garner.config.cache.fetch(index_string_for(klass, object), {}) do
+              new_key_prefix_for(klass, object)
+            end
+          end
+
+          def new_key_prefix_for(klass, object = nil)
+            Digest::MD5.hexdigest("#{klass}/#{object || "*"}:#{new_key_postfix}")
+          end
+          
+          def new_key_postfix
+            SecureRandom.respond_to?(:uuid) ? SecureRandom.uuid : (0...16).map{ ('a'..'z').to_a[rand(26)] }.join
+          end
+
+          def standardize(binding)
+            case binding
+            when Hash
+              binding
+            when Array
+              bind_array(binding)
+            when NilClass
+              nil
+            end
+          end
+          
+          # Generate a metadata key.
+          def meta(key)
+            "#{key}:meta"
+          end
+
+          def bind_array(ary)
+            case ary[0]
+            when Array, Hash
+              ary.collect { |subary| standardize(subary) }
+            when Class
+              h = { :klass => ary[0] }
+              h.merge!({
+                :object => (ary[1].is_a?(Hash) ? ary[1] : { IDENTITY_FIELDS.first => ary[1] })
+              }) if ary[1]
+              h
+            else
+              raise ArgumentError, "invalid argument type #{ary[0].class} in :bind (#{ary[0]})"
+            end
+          end
+          
+          def index_string_for(klass, object = nil)
+            prefix = "INDEX"
+            IDENTITY_FIELDS.each do |field|
+              if object && object[field]
+                return "#{prefix}:#{klass}/#{field}=#{object[field]}"
+              end
+            end
+            "#{prefix}:#{klass}/*"
+          end
+          
+      end
+    end
+  end
+end

data/lib/garner/config.rb

@@ -0,0 +1,101 @@
+module Garner
+
+  class << self
+
+    # Set the configuration options. Best used by passing a block.
+    #
+    # @example Set up configuration options.
+    #   Garner.configure do |config|
+    #     config.cache = Rails.cache
+    #   end
+    #
+    # @return [ Config ] The configuration obejct.
+    def configure
+      block_given? ? yield(Garner::Config) : Garner::Config
+    end
+    alias :config :configure
+  end
+
+  module Config
+    extend self
+
+    # Current configuration settings.
+    attr_accessor :settings
+    
+    # Default configuration settings.
+    attr_accessor :defaults
+    
+    @settings = {}
+    @defaults = {}
+
+    # Define a configuration option with a default.
+    #
+    # @example Define the option.
+    #   Config.option(:cache, :default => nil)
+    #
+    # @param [ Symbol ] name The name of the configuration option.
+    # @param [ Hash ] options Extras for the option.
+    #
+    # @option options [ Object ] :default The default value.
+    def option(name, options = {})
+      defaults[name] = settings[name] = options[:default]
+
+      class_eval <<-RUBY
+        def #{name}
+          settings[#{name.inspect}]
+        end
+
+        def #{name}=(value)
+          settings[#{name.inspect}] = value
+        end
+
+        def #{name}?
+          #{name}
+        end
+      RUBY
+    end
+    
+    # Returns the default cache store, either Rails.cache or an instance of ActiveSupport::Cache::MemoryStore.
+    #
+    # @example Get the default cache store
+    #   config.default_cache
+    #
+    # @return [ Cache ] The default cache store instance.
+    def default_cache
+      defined?(Rails) && Rails.respond_to?(:cache) ? Rails.cache : ::ActiveSupport::Cache::MemoryStore.new
+    end
+
+    # Returns the cache, or defaults to Rails cache when running in Rails or an instance of ActiveSupport::Cache::MemoryStore otherwise.
+    #
+    # @example Get the cache.
+    #   config.cache
+    #
+    # @return [ Cache ] The configured cache or a default cache instance.
+    def cache
+      settings[:cache] = default_cache unless settings.has_key?(:cache)
+      settings[:cache]
+    end
+
+    # Sets the cache to use.
+    #
+    # @example Set the cache.
+    #   config.cache = Rails.cache
+    #
+    # @return [ Cache ] The newly set cache.
+    def cache=(cache)
+      settings[:cache] = cache
+    end
+
+    # Reset the configuration options to the defaults.
+    #
+    # @example Reset the configuration options.
+    #   config.reset!
+    def reset!
+      settings.replace(defaults)
+    end
+   
+    # Default cache expiration time.
+    option(:expires_in, :default => nil)
+  end
+end
+

data/lib/garner/middleware/base.rb

@@ -0,0 +1,47 @@
+# Based on https://github.com/intridea/grape/blob/master/lib/grape/middleware/base.rb.
+module Garner
+  module Middleware
+    class Base
+      attr_reader :app, :env, :options
+
+      # @param [Rack Application] app The standard argument for a Rack middleware.
+      # @param [Hash] options A hash of options, simply stored for use by subclasses.
+      def initialize(app, options = {})
+        @app = app
+        @options = default_options.merge(options)
+      end
+
+      def default_options; {} end
+
+      def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
+        @env = env
+        before
+        @app_response = @app.call(@env)
+        after || @app_response
+      end
+
+      # @abstract
+      # Called before the application is called in the middleware lifecycle.
+      def before; end
+      
+      # @abstract
+      # Called after the application is called in the middleware lifecycle.
+      # @return [Response, nil] a Rack SPEC response or nil to call the application afterwards.
+      def after; end
+
+      def request
+        Rack::Request.new(self.env)
+      end
+
+      def response
+        Rack::Response.new(@app_response)
+      end
+
+    end
+  end
+end
+

data/lib/garner/middleware/cache/bust.rb

@@ -0,0 +1,20 @@
+module Garner
+  module Middleware
+    module Cache
+      # @abstract
+      # Add the necessary Cache-Control and Expires headers to bust client cache.
+      class Bust < Garner::Middleware::Base      
+        def after
+          # private: ok to store API results in a private cache
+          # max-age: don't reuse the cached result without checking with the server (server might say 304 Not Modified)
+          # must-revalidate: prevent gateways from returning a response if the API server is not reachable
+          @app_response[1]["Cache-Control"] = "private, max-age=0, must-revalidate"
+          # don't reuse the cached result without checking with the server
+          @app_response[1]["Expires"] = "Fri, 01 Jan 1990 00:00:00 GMT"
+          @app_response
+        end
+      end
+    end
+  end
+end
+

data/lib/garner/mixins/grape_cache.rb

@@ -0,0 +1,104 @@
+module Garner
+  module Mixins
+    module Grape
+      #
+      # A cache that supports conditional GETs
+      #
+      # Borrows generously from http://themomorohoax.com/2009/01/07/using-stale-with-rails-to-return-304-not-modified
+      # See also RFC 2616: http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.3.4
+      #   for explanation of how If-Modified-Since and If-None-Match request headers are handled.
+      #
+      module Cache
+      
+        def cache_enabled?
+          true
+        end
+  
+        # cache a record
+        def cache(options = {}, &block)
+          unless cache_enabled?
+            yield
+          else
+            binding, context = cache_binding_and_context(options)
+            Garner::Cache::ObjectIdentity.cache(binding, context) do
+              yield
+            end
+          end
+        end
+        
+        # invalidate a cache record
+        def invalidate(*args)
+          Garner::Cache::ObjectIdentity.invalidate(* args)
+        end
+  
+        def cache_or_304(options = {}, &block)
+          binding, context = cache_binding_and_context(options)
+          # metadata written in a previous GET
+          metadata = Garner::Cache::ObjectIdentity.cache_metadata(binding, context)
+          error!("Not Modified", 304) if metadata && fresh?(metadata)
+          rc = cache(options, &block)
+          # metadata has been generated by cache
+          metadata = Garner::Cache::ObjectIdentity.cache_metadata(binding, context)
+          self.last_modified = metadata[:last_modified]
+          self.etag = metadata[:etag]
+          rc
+        end
+  
+        private
+          
+          def cache_binding_and_context(options)
+            cache_context = {}
+            cache_context.merge!(options.dup)
+            cache_context[:request] = request
+            cache_context.delete(:bind)
+            cache_binding = (options || {})[:bind]
+            cache_binding = cache_binding ? { :bind => cache_binding } : {}
+            [ cache_binding, cache_context ]
+          end
+
+          def fresh?(metadata = {})
+            case
+            when if_modified_since && if_none_match
+              not_modified?(metadata[:last_modified]) && etag_matches?(metadata[:etag])
+            when if_modified_since
+              not_modified?(metadata[:last_modified])
+            when if_none_match
+              etag_matches?(metadata[:etag])
+            else
+              false
+            end
+          end
+    
+          def if_modified_since
+            if since = env["HTTP_IF_MODIFIED_SINCE"]
+              Time.rfc2822(since) rescue nil
+            end
+          end
+
+          def if_none_match
+            env["HTTP_IF_NONE_MATCH"]
+          end
+
+          def not_modified?(modified_at)
+            if_modified_since && modified_at && if_modified_since >= modified_at
+          end
+
+          def etag_matches?(etag)
+            if_none_match && if_none_match == etag
+          end
+        
+          def last_modified=(utc_time)
+            return unless utc_time
+            header "Last-Modified", utc_time.httpdate
+          end
+        
+          def etag=(etag)
+            return unless etag
+            header "ETag", etag
+          end
+          
+      end
+    end
+  end
+end
+

data/lib/garner/mixins/mongoid_document.rb

@@ -0,0 +1,49 @@
+module Garner
+  module Mixins
+    module Mongoid
+      module Document
+        extend ActiveSupport::Concern
+
+        included do
+          before_save :invalidate_api_cache
+          before_destroy :invalidate_api_cache
+          cattr_accessor :api_cache_class
+        end
+
+        # invalidate API cache
+        def invalidate_api_cache
+          self.all_embedding_documents.each { |doc| doc.invalidate_api_cache }
+          cache_class = self.class.api_cache_class || self.class
+          Garner::Cache::ObjectIdentity::IDENTITY_FIELDS.each do |identity_field|
+            next unless self.respond_to?(identity_field)
+            Garner::Cache::ObjectIdentity.invalidate(cache_class, { identity_field => self.send(identity_field) })
+          end
+          Garner::Cache::ObjectIdentity.invalidate(cache_class)
+        end
+        
+        # navigate the parent embedding document hierarchy
+        def all_embedding_documents
+          obj = self
+          docs = []
+          while obj.metadata && obj.embedded?
+            break if docs.detect { |doc| doc.class == obj.class }
+            parent = obj.send(obj.metadata.inverse)
+            docs << parent
+            obj = parent
+          end
+          docs
+        end
+
+        module ClassMethods
+          # Including classes can call `cache_as` to specify a different class
+          # on which to bind API cache objects.
+          # @example `Admin`, which extends `User` should call `cache_as User`
+          def cache_as(klass)
+            self.api_cache_class = klass
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/garner/objects/etag.rb

@@ -0,0 +1,20 @@
+module Garner
+  module Objects
+    module ETag
+      class << self
+        # @abstract
+        # Serialize in a way such that the ETag matches that which would 
+        # be returned by Rack::ETag at response time.
+        def from(object)
+          serialization = case object
+            when nil then ""
+            when String then object
+            when Hash then object.respond_to?(:to_json) ? object.to_json : MultiJson.dump(object)
+            else Marshal.dump(object)
+          end
+          %("#{Digest::MD5.hexdigest(serialization)}")
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/cache/expiration_strategy.rb

@@ -0,0 +1,16 @@
+module Garner
+  module Strategies
+    module Cache
+      # Injects an expires_in value from the globl configuration.
+      module Expiration
+        class << self
+          def apply(current, options = {})
+            rc = current ? current.dup : {}
+            rc[:expires_in] = Garner.config.expires_in if Garner.config.expires_in && ! current[:expires_in]
+            rc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/keys/caller_strategy.rb

@@ -0,0 +1,29 @@
+module Garner
+  module Strategies
+    module Keys
+      # Injects the caller's location into the key.
+      module Caller
+        class << self
+        
+          def field
+            :caller
+          end
+          
+          def apply(key, context = {})
+            rc = key ? key.dup : {}
+            clr = nil
+            caller.each do |line|
+              split = line.split(":")
+              next unless split.length >= 2
+              path = Pathname.new(split[0]).realpath.to_s
+              next unless path.include?("/app/") || path.include?("/spec/")
+              rc[field] = "#{path}:#{split[1]}"
+              break
+            end
+            rc
+          end
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/keys/request_get_strategy.rb

@@ -0,0 +1,22 @@
+module Garner
+  module Strategies
+    module Keys
+      # Inject the request GET parameters into the key.
+      module RequestGet
+        class << self
+        
+          def field
+            :params
+          end
+          
+          def apply(key, context = {})
+            key = key ? key.dup : {}
+            key[field] = context[:request].GET.dup if context && context[:request]
+            key
+          end
+          
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/keys/request_path_strategy.rb

@@ -0,0 +1,21 @@
+module Garner
+  module Strategies
+    module Keys
+      # Inject the request path into the key.
+      module RequestPath
+        class << self
+        
+          def field
+            :path
+          end
+          
+          def apply(key, context = {})
+            key = key ? key.dup : {}
+            key[field] = context[:request].path if context && context[:request] && context[:request].respond_to?(:path)
+            key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/keys/version_strategy.rb

@@ -0,0 +1,29 @@
+module Garner
+  module Strategies
+    module Keys
+      # Inject the request path into the key.
+      module Version
+        class << self
+        
+          def field
+            :version
+          end
+          
+          def default_version
+            nil
+          end
+          
+          def apply(key, context = {})
+            key = key ? key.dup : {}
+            if context && context[:version]
+              key[:version] = context[:version] 
+            elsif default_version
+              key[:version] = default_version
+            end
+            key
+          end
+        end
+      end
+    end
+  end
+end

data/lib/garner/version.rb

@@ -0,0 +1,5 @@
+module Garner
+  VERSION = '0.1.1'
+end
+
+

data/lib/garner.rb

@@ -0,0 +1,22 @@
+require 'multi_json'
+require 'active_support'
+# garner
+require 'garner/version'
+require 'garner/config'
+# objects
+require 'garner/objects/etag'
+# middleware
+require 'garner/middleware/base'
+require 'garner/middleware/cache/bust'
+# key strategies
+require 'garner/strategies/keys/version_strategy'
+require 'garner/strategies/keys/caller_strategy'
+require 'garner/strategies/keys/request_path_strategy'
+require 'garner/strategies/keys/request_get_strategy'
+# cache option strategies
+require 'garner/strategies/cache/expiration_strategy'
+# caches
+require 'garner/cache/object_identity'
+# mixins
+require 'garner/mixins/grape_cache'
+require 'garner/mixins/mongoid_document'

metadata

@@ -0,0 +1,223 @@
+--- !ruby/object:Gem::Specification
+name: garner
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Doubrovkine
+- Frank Macreery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: &70275893494820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70275893494820
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: &70275893493960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70275893493960
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70275893493440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70275893493440
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70275893492560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70275893492560
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70275893491640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70275893491640
+- !ruby/object:Gem::Dependency
+  name: grape
+  requirement: &70275893490880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: *70275893490880
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: &70275893489940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :development
+  prerelease: false
+  version_requirements: *70275893489940
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70275893489020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.10'
+  type: :development
+  prerelease: false
+  version_requirements: *70275893489020
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70275893503600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: *70275893503600
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: &70275893502040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: *70275893502040
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: &70275893500500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: *70275893500500
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70275893499420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70275893499420
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: &70275893498780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70275893498780
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: &70275893498280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70275893498280
+description: Garner is a set of Rack middleware and cache helpers that implement various
+  strategies.
+email: dblock@dblock.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.md
+- README.md
+files:
+- lib/garner.rb
+- lib/garner/cache/object_identity.rb
+- lib/garner/config.rb
+- lib/garner/middleware/base.rb
+- lib/garner/middleware/cache/bust.rb
+- lib/garner/mixins/grape_cache.rb
+- lib/garner/mixins/mongoid_document.rb
+- lib/garner/objects/etag.rb
+- lib/garner/strategies/cache/expiration_strategy.rb
+- lib/garner/strategies/keys/caller_strategy.rb
+- lib/garner/strategies/keys/request_get_strategy.rb
+- lib/garner/strategies/keys/request_path_strategy.rb
+- lib/garner/strategies/keys/version_strategy.rb
+- lib/garner/version.rb
+- LICENSE.md
+- README.md
+homepage: http://github.com/dblock/garner
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3544902871771726004
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Garner is a set of Rack middleware and cache helpers that implement various
+  strategies.
+test_files: []