garner 0.3.3 → 0.4.0

data/lib/garner/mixins/mongoid/document.rb

@@ -0,0 +1,75 @@
+# Set up Garner configuration parameters
+Garner.config.option(:mongoid_binding_key_strategy, {
+  :default => Garner.config.binding_key_strategy
+})
+
+Garner.config.option(:mongoid_binding_invalidation_strategy, {
+  :default => Garner.config.binding_invalidation_strategy
+})
+
+module Garner
+  module Mixins
+    module Mongoid
+      module Document
+        extend ActiveSupport::Concern
+        include Garner::Cache::Binding
+
+        def key_strategy
+          Garner.config.mongoid_binding_key_strategy
+        end
+
+        def invalidation_strategy
+          Garner.config.mongoid_binding_invalidation_strategy
+        end
+
+        included do
+          extend Garner::Cache::Binding
+
+          def self.cache_key
+            _latest_by_updated_at.try(:cache_key)
+          end
+
+          def self.touch
+            _latest_by_updated_at.try(:touch)
+          end
+
+          def self.updated_at
+            _latest_by_updated_at.try(:updated_at)
+          end
+
+          def self.key_strategy
+            Garner.config.mongoid_binding_key_strategy
+          end
+
+          def self.invalidation_strategy
+            Garner.config.mongoid_binding_invalidation_strategy
+          end
+
+          def self.identify(id)
+            Garner::Mixins::Mongoid::Identity.from_class_and_id(self, id)
+          end
+
+          def self.garnered_find(id)
+            return nil unless (binding = identify(id))
+            identity = Garner::Cache::Identity.new
+            identity.bind(binding).key({ :source => :garnered_find }) { find(id) }
+          end
+
+          after_create    :_garner_after_create
+          after_update    :_garner_after_update
+          after_destroy   :_garner_after_destroy
+
+          protected
+          def self._latest_by_updated_at
+            # Only find the latest if we can order by :updated_at
+            return nil unless fields["updated_at"]
+            only(:_id, :_type, :updated_at).order_by({
+              :updated_at => :desc
+            }).first
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/garner/mixins/mongoid/identity.rb

@@ -0,0 +1,106 @@
+# Set up Garner configuration parameters
+Garner.config.option(:mongoid_identity_fields, {
+  :default => [:_id]
+})
+
+module Garner
+  module Mixins
+    module Mongoid
+      class Identity
+        include Garner::Cache::Binding
+
+        attr_accessor :document, :collection_name, :conditions
+
+        def self.from_class_and_id(klass, id)
+          validate_class!(klass)
+
+          self.new.tap do |identity|
+            identity.collection_name = klass.collection_name
+            identity.conditions = conditions_for(klass, id)
+          end
+        end
+
+        def initialize
+          @conditions = {}
+        end
+
+        def key_strategy
+          Garner.config.mongoid_binding_key_strategy
+        end
+
+        def invalidation_strategy
+          Garner.config.mongoid_binding_invalidation_strategy
+        end
+
+        def cache_key
+          # See https://github.com/mongoid/mongoid/blob/f5ba1295/lib/mongoid/document.rb#L242
+          if updated_at
+            "#{model_cache_key}/#{_id}-#{updated_at.utc.to_s(:number)}"
+          elsif _id
+            "#{model_cache_key}/#{_id}"
+          else
+            "#{model_cache_key}/new"
+          end
+        end
+
+        def model_cache_key
+          if _type
+            ActiveModel::Name.new(_type.constantize).cache_key
+          else
+            @collection_name.to_s
+          end
+        end
+
+        def collection
+          ::Mongoid.default_session[@collection_name]
+        end
+
+        def document
+          return @document if @document
+
+          collection.where(@conditions).select({
+            :_id => 1,
+            :_type => 1,
+            :updated_at => 1
+          }).limit(1).first
+        end
+
+        def _id
+          document["_id"] if document
+        end
+
+        def updated_at
+          document["updated_at"] if document
+        end
+
+        def _type
+          document["_type"] if document
+        end
+
+        private
+        def self.validate_class!(klass)
+          if !klass.include?(::Mongoid::Document)
+            raise "Must instantiate from a Mongoid class"
+          elsif klass.embedded?
+            raise "Cannot instantiate from an embedded document class"
+          end
+        end
+
+        def self.conditions_for(klass, id)
+          # multiple-ID conditions
+          conditions = {
+            "$or" => Garner.config.mongoid_identity_fields.map { |field|
+              { field => id }
+            }
+          }
+
+          # _type conditions
+          selector = klass.where({})
+          conditions.merge!(selector.send(:type_selection)) if selector.send(:type_selectable?)
+
+          conditions
+        end
+      end
+    end
+  end
+end

data/lib/garner/mixins/mongoid.rb

@@ -0,0 +1,4 @@
+require "garner"
+
+require "garner/mixins/mongoid/document"
+require "garner/mixins/mongoid/identity"

data/lib/garner/mixins/rack.rb

@@ -0,0 +1,45 @@
+require "garner"
+
+# Set up Garner configuration parameters
+Garner.config.option(:rack_context_key_strategies, {
+  :default => [
+    Garner::Strategies::Context::Key::Caller,
+    Garner::Strategies::Context::Key::RequestGet,
+    Garner::Strategies::Context::Key::RequestPost,
+    Garner::Strategies::Context::Key::RequestPath
+  ]
+})
+
+module Garner
+  module Mixins
+    module Rack
+
+      # Override this method to conditionally disable the cache.
+      #
+      # @return [Boolean]
+      def cache_enabled?
+        true
+      end
+
+      # Instantiate a context-appropriate cache identity.
+      #
+      # @example
+      #   garner.bind(current_user) do
+      #     { count: current_user.logins.count }
+      #   end
+      # @return [Garner::Cache::Identity] The cache identity.
+      def garner(&block)
+        identity = Garner::Cache::Identity.new
+        Garner.config.rack_context_key_strategies.each do |strategy|
+          identity = strategy.apply(identity, self)
+        end
+
+        unless cache_enabled?
+          identity.options({ :force_miss => true })
+        end
+
+        block_given? ? identity.fetch(&block) : identity
+      end
+    end
+  end
+end

data/lib/garner/strategies/binding/invalidation/base.rb

@@ -0,0 +1,26 @@
+module Garner
+  module Strategies
+    module Binding
+      module Invalidation
+        class Base
+
+          # Specifies whether invalidation should happen on callbacks.
+          #
+          # @param kind [Symbol] One of :create, :update, :destroy
+          def self.apply_on_callback?(kind = nil)
+            true
+          end
+
+          # Force-invalidate an object binding. Used when bindings are
+          # explicitly invalidated, via binding.invalidate_garner_caches.
+          #
+          # @param binding [Object] The binding whose caches are to be
+          #   invalidated.
+          def self.apply(binding)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/garner/strategies/binding/invalidation/touch.rb

@@ -0,0 +1,27 @@
+module Garner
+  module Strategies
+    module Binding
+      module Invalidation
+        class Touch < Base
+
+          # Specifies whether invalidation should happen on callbacks.
+          #
+          # @param kind [Symbol] One of :create, :update, :destroy
+          def self.apply_on_callback?(kind = nil)
+            false
+          end
+
+          # Force-invalidate an object binding. Used when bindings are
+          # explicitly invalidated, via binding.invalidate_garner_caches.
+          #
+          # @param binding [Object] The binding whose caches are to be
+          #   invalidated.
+          def self.apply(binding)
+            binding.touch if binding.respond_to?(:touch)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/garner/strategies/binding/key/base.rb

@@ -0,0 +1,19 @@
+module Garner
+  module Strategies
+    module Binding
+      module Key
+        class Base
+
+          # Compute a cache key from an object binding.
+          #
+          # @param binding [Object] The object from which to compute a key.
+          # @return [String] A cache key string.
+          def self.apply(binding)
+            nil
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/binding/key/cache_key.rb

@@ -0,0 +1,19 @@
+module Garner
+  module Strategies
+    module Binding
+      module Key
+        class CacheKey < Base
+
+          # Compute a cache key from an object binding.
+          #
+          # @param binding [Object] The object from which to compute a key.
+          # @return [String] A cache key string.
+          def self.apply(binding)
+            binding.cache_key if binding.respond_to?(:cache_key)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/binding/key/safe_cache_key.rb

@@ -0,0 +1,33 @@
+module Garner
+  module Strategies
+    module Binding
+      module Key
+        class SafeCacheKey < Base
+          VALID_FORMAT = /^(?<model>[^\/]+)\/(?<id>.+)-(?<timestamp>[0-9]{14})$/
+
+          # Compute a cache key from an object binding. Only return a key if
+          # :cache_key and :updated_at are both defined and present on the
+          # object, and if :cache_key conforms to the ActiveModel format.
+          #
+          # If all requirements are met, append the millisecond portion of
+          # :updated_at to :cache_key.
+          #
+          # @param binding [Object] The object from which to compute a key.
+          # @return [String] A cache key string.
+          def self.apply(binding)
+            return unless binding.respond_to?(:cache_key) && binding.cache_key
+            return unless binding.respond_to?(:updated_at) && binding.updated_at
+
+            # Check for ActiveModel cache key format
+            return unless binding.cache_key =~ VALID_FORMAT
+
+            decimal_portion = binding.updated_at.utc.to_f % 1
+            decimal_string = sprintf("%.10f", decimal_portion).gsub(/^0/, "")
+            "#{binding.cache_key}#{decimal_string}"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/context/key/base.rb

@@ -0,0 +1,21 @@
+module Garner
+  module Strategies
+    module Context
+      module Key
+        class Base
+
+          # Compute a hash of key-value pairs from a given ruby context,
+          # and apply it to a cache identity.
+          #
+          # @param identity [Garner::Cache::Identity] The cache identity.
+          # @param ruby_context [Object] An optional Ruby context.
+          # @return [Garner::Cache::Identity] The modified identity.
+          def self.apply(identity, ruby_context = self)
+            identity
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/context/key/caller.rb

@@ -0,0 +1,83 @@
+module Garner
+  module Strategies
+    module Context
+      module Key
+        class Caller < Base
+
+          def self.field
+            :caller
+          end
+
+          # Determine the most likely root path for the current Garner client
+          # application. If in a Rails application, Rails.root is used.
+          # Otherwise, the nearest ancestor directory containing a Gemfile is
+          # used.
+          #
+          # @see Garner::Config#caller_root=
+          # @see Garner::Config#default_caller_root
+          # @return [String] The default root path.
+          def self.default_root
+            if defined?(::Rails) && ::Rails.respond_to?(:root)
+              ::Rails.root
+            else
+              # Try to use the nearest ancestor directory containing a Gemfile.
+              requiring_caller = send(:caller).detect do |line|
+                !line.include?(File.join("lib", "garner"))
+              end
+              return nil unless requiring_caller
+
+              requiring_file = requiring_caller.split(":")[0]
+              gemfile_root(File.dirname(requiring_file))
+            end
+          end
+
+          # Injects the caller's location into the key hash.
+          #
+          # @param identity [Garner::Cache::Identity] The cache identity.
+          # @param ruby_context [Object] An optional Ruby context.
+          # @return [Garner::Cache::Identity] The modified identity.
+          def self.apply(identity, ruby_context = self)
+            value = nil
+
+            if ruby_context.send(:caller)
+              ruby_context.send(:caller).compact.each do |line|
+                parts = line.match(/(?<filename>[^:]+)\:(?<lineno>[^:]+)/)
+                file = (Pathname.new(parts[:filename]).realpath.to_s rescue nil)
+                next if file.nil? || file == ""
+                next if file.include?(File.join("lib", "garner"))
+
+                if (root = Garner.config.caller_root)
+                  root += File::SEPARATOR unless root[-1] == File::SEPARATOR
+                  next unless file =~ /^#{root}/
+                  value = "#{file.gsub(root || "", "")}:#{parts[:lineno]}"
+                else
+                  value = "#{file}:#{parts[:lineno]}"
+                end
+
+                break
+              end
+            end
+
+            value ? identity.key(field => value) : identity
+          end
+
+          private
+          def self.gemfile_root(path)
+            path = Pathname.new(path).realpath.to_s
+            newpath = Pathname.new(File.join(path, "..")).realpath.to_s
+            if newpath == path
+              # We've reached the filesystem root; return
+              return nil
+            elsif File.exist?(File.join(newpath, "Gemfile"))
+              # We've struck Gemfile gold; return current path
+              return newpath
+            else
+              return gemfile_root(newpath)
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/context/key/jsonp.rb

@@ -0,0 +1,30 @@
+module Garner
+  module Strategies
+    module Context
+      module Key
+        class Jsonp < Base
+
+          def self.field
+            :request_params
+          end
+
+          # Strips JSONP parameters from the key.
+          #
+          # @param identity [Garner::Cache::Identity] The cache identity.
+          # @param ruby_context [Object] An optional Ruby context.
+          # @return [Garner::Cache::Identity] The modified identity.
+          def self.apply(identity, ruby_context = self)
+            key_hash = identity.key_hash
+            return identity unless key_hash[field]
+
+
+            key_hash[field].delete("callback")
+            key_hash[field].delete("_")
+            identity
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/context/key/request_get.rb

@@ -0,0 +1,30 @@
+module Garner
+  module Strategies
+    module Context
+      module Key
+        class RequestGet < Base
+
+          def self.field
+            :request_params
+          end
+
+          # Injects the request GET parameters into the key hash.
+          #
+          # @param identity [Garner::Cache::Identity] The cache identity.
+          # @param ruby_context [Object] An optional Ruby context.
+          # @return [Garner::Cache::Identity] The modified identity.
+          def self.apply(identity, ruby_context = self)
+            return identity unless (ruby_context.respond_to?(:request))
+
+            request = ruby_context.request
+            if request && ["GET", "HEAD"].include?(request.request_method)
+              identity.key(field => request.GET.dup)
+            end
+            identity
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/context/key/request_path.rb

@@ -0,0 +1,28 @@
+module Garner
+  module Strategies
+    module Context
+      module Key
+        class RequestPath < Base
+
+          def self.field
+            :request_path
+          end
+
+          # Injects the request path into the key hash.
+          #
+          # @param identity [Garner::Cache::Identity] The cache identity.
+          # @param ruby_context [Object] An optional Ruby context.
+          # @return [Garner::Cache::Identity] The modified identity.
+          def self.apply(identity, ruby_context = self)
+            return identity unless (ruby_context.respond_to?(:request))
+
+            request = ruby_context.request
+            identity.key(field => request.path) if request.respond_to?(:path)
+            identity
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/strategies/context/key/request_post.rb

@@ -0,0 +1,30 @@
+module Garner
+  module Strategies
+    module Context
+      module Key
+        class RequestPost < Base
+
+          def self.field
+            :request_params
+          end
+
+          # Injects the request POST parameters into the key hash.
+          #
+          # @param identity [Garner::Cache::Identity] The cache identity.
+          # @param ruby_context [Object] An optional Ruby context.
+          # @return [Garner::Cache::Identity] The modified identity.
+          def self.apply(identity, ruby_context = self)
+            return identity unless (ruby_context.respond_to?(:request))
+
+            request = ruby_context.request
+            if request.request_method == "POST"
+              identity = identity.key(field => request.POST.dup)
+            end
+            identity
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/garner/version.rb

@@ -1,3 +1,3 @@
 module Garner
-  VERSION = '0.3.3'
+  VERSION = "0.4.0"
 end

data/lib/garner.rb

@@ -1,26 +1,29 @@
-require 'multi_json'
-require 'active_support'
-# garner
-require 'garner/version'
-require 'garner/config'
-# 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'
-require 'garner/strategies/keys/request_post_strategy'
-require 'garner/strategies/keys/key_strategy'
-require 'garner/strategies/keys/jsonp_strategy'
-# etag strategies
-require 'garner/strategies/etags/grape_strategy'
-require 'garner/strategies/etags/marshal_strategy'
-# cache option strategies
-require 'garner/strategies/cache/expiration_strategy'
-# caches
-require 'garner/cache/object_identity'
-# mixins
-require 'garner/mixins/grape_cache' if defined?(Grape)
-require 'garner/mixins/mongoid_document' if defined?(Mongoid)
+require "multi_json"
+require "active_support"
+
+# Garner core
+require "garner/version"
+require "garner/config"
+
+# Key strategies
+require "garner/strategies/context/key/base"
+require "garner/strategies/context/key/caller"
+require "garner/strategies/context/key/request_path"
+require "garner/strategies/context/key/request_get"
+require "garner/strategies/context/key/request_post"
+require "garner/strategies/context/key/jsonp"
+
+# Binding strategies
+require "garner/strategies/binding/key/base"
+require "garner/strategies/binding/key/cache_key"
+require "garner/strategies/binding/key/safe_cache_key"
+
+# Invalidation strategies
+require "garner/strategies/binding/invalidation/base"
+require "garner/strategies/binding/invalidation/touch"
+
+# Cache
+require "garner/cache"
+require "garner/cache/identity"
+require "garner/cache/context"
+require "garner/cache/binding"