mongoid-query_cache 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c0ccfe940fad749e4ceafff08dc37a188506349
+  data.tar.gz: 02bfa64270f52dfa363a3f5cec8d0e6008593b69
+SHA512:
+  metadata.gz: 72155e3fa5918d6dcd918b9288867f9a5b00a86b56c851c75a08b9ebd28f730aba400e958c384878dd24dabb0651bc09c8ec5dffb8c0908303acece8932b7afb
+  data.tar.gz: 5a3dc435fcdfbbc39ed2c6d062d608cba4427d9cfe94d987868e3c2666dc8c96d9d60295b85b2e9a83b4a96127cf0a7ceb94c0bf7932a5c1e7f1706463c0f939

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mongoid-query_cache.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Philip Claren
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Philip Claren
+
+MIT License
+
+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,4 @@
+Mongoid3-Query-Cache
+====================
+
+Backport of the Mongoid 4 QueryCache for Mongoid 3.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/mongoid/query_cache.rb

@@ -0,0 +1,233 @@
+require 'mongoid/query_cache/version'
+require 'mongoid/query_cache/railtie' if defined? Rails
+
+module Mongoid
+
+  # A cache of database queries on a per-request basis.
+  #
+  module QueryCache
+    class << self
+
+      # Get the cached queries.
+      #
+      # @example Get the cached queries from the current thread.
+      #   QueryCache.cache_table
+      #
+      # @return [ Hash ] The hash of cached queries.
+      #
+      def cache_table
+        Thread.current["[mongoid]:query_cache"] ||= {}
+      end
+
+      # Clear the query cache.
+      #
+      # @example Clear the cache.
+      #   QueryCache.clear_cache
+      #
+      # @return [ nil ] Always nil.
+      #
+      def clear_cache
+        Thread.current["[mongoid]:query_cache"] = nil
+      end
+
+      # Set whether the cache is enabled.
+      #
+      # @example Set if the cache is enabled.
+      #   QueryCache.enabled = true
+      #
+      # @param [ true, false ] value The enabled value.
+      #
+      def enabled=(value)
+        Thread.current["[mongoid]:query_cache:enabled"] = value
+      end
+
+      # Is the query cache enabled on the current thread?
+      #
+      # @example Is the query cache enabled?
+      #   QueryCache.enabled?
+      #
+      # @return [ true, false ] If the cache is enabled.
+      #
+      def enabled?
+        !!Thread.current["[mongoid]:query_cache:enabled"]
+      end
+
+      # Execute the block while using the query cache.
+      #
+      # @example Execute with the cache.
+      #   QueryCache.cache { collection.find }
+      #
+      # @return [ Object ] The result of the block.
+      #
+      def cache
+        enabled = QueryCache.enabled?
+        QueryCache.enabled = true
+        yield
+      ensure
+        QueryCache.enabled = enabled
+      end
+    end
+
+    # The middleware to be added to a rack application in order to activate the
+    # query cache.
+    #
+    class Middleware
+
+      # Instantiate the middleware.
+      #
+      # @example Create the new middleware.
+      #   Middleware.new(app)
+      #
+      # @param [ Object ] app The rack applciation stack.
+      #
+      def initialize(app)
+        @app = app
+      end
+
+      # Execute the request, wrapping in a query cache.
+      #
+      # @example Execute the request.
+      #   middleware.call(env)
+      #
+      # @param [ Object ] env The environment.
+      #
+      # @return [ Object ] The result of the call.
+      #
+      def call(env)
+        QueryCache.cache { @app.call(env) }
+      ensure
+        QueryCache.clear_cache
+      end
+    end
+
+    module Base # :nodoc:
+
+      def alias_query_cache_clear(*method_names)
+        method_names.each do |method_name|
+          class_eval <<-CODE, __FILE__, __LINE__ + 1
+              def #{method_name}_with_clear_cache(*args)   # def upsert_with_clear_cache(*args)
+                QueryCache.clear_cache                     #   QueryCache.clear_cache
+                #{method_name}_without_clear_cache(*args)  #   upsert_without_clear_cache(*args)
+              end                                          # end
+          CODE
+
+          alias_method_chain method_name, :clear_cache
+        end
+      end
+    end
+
+    # Module to include in objects which need to wrap caching behaviour around
+    # them.
+    #
+    module Cacheable
+
+      private
+
+      def with_cache(context = :cursor, &block)
+        return yield unless QueryCache.enabled?
+        return yield if system_collection?
+        key = cache_key.push(context)
+
+        if QueryCache.cache_table.has_key?(key)
+          instrument(key) { QueryCache.cache_table[key] }
+        else
+          QueryCache.cache_table[key] = yield
+        end
+      end
+
+      def instrument(key, &block)
+        ActiveSupport::Notifications.instrument("query_cache.mongoid", key: key, &block)
+      end
+    end
+
+    # Adds behaviour around caching to a Moped Query object.
+    #
+    module Query
+      extend ActiveSupport::Concern
+      include Cacheable
+
+      included do
+        extend QueryCache::Base
+        alias_method_chain :cursor, :cache
+        alias_method_chain :first, :cache
+        alias_query_cache_clear :remove, :remove_all, :update, :update_all, :upsert
+      end
+
+      # Provide a wrapped query cache cursor.
+      #
+      # @example Get the wrapped caching cursor.
+      #   query.cursor_with_cache
+      #
+      # @return [ CachedCursor ] The cached cursor.
+      #
+      def cursor_with_cache
+        CachedCursor.new(session, operation)
+      end
+
+      # Override first with caching.
+      #
+      # @example Get the first with a cache.
+      #   query.first_with_cache
+      #
+      # @return [ Hash ] The first document.
+      #
+      def first_with_cache
+        with_cache(:first) do
+          first_without_cache
+        end
+      end
+
+      private
+
+      def cache_key
+        [ operation.database, operation.collection, operation.selector, operation.limit, operation.skip, operation.fields ]
+      end
+
+      def system_collection?
+        operation.collection =~ /^system./
+      end
+    end
+
+    # Adds behaviour to the query cache for collections.
+    #
+    module Collection
+      extend ActiveSupport::Concern
+
+      included do
+        extend QueryCache::Base
+        alias_query_cache_clear :insert
+      end
+    end
+
+    # A Cursor that attempts to load documents from memory first before hitting
+    # the database if the same query has already been executed.
+    #
+    class CachedCursor < Moped::Cursor
+      include Cacheable
+
+      # Override the loading of docs to attempt to fetch from the cache.
+      #
+      # @example Load the documents.
+      #   cursor.load_docs
+      #
+      # @return [ Array<Hash> ] The documents.
+      #
+      def load_docs
+        with_cache { super }
+      end
+
+      private
+
+      def cache_key
+        [ @database, @collection, @selector, @options[:limit], @options[:skip], @options[:fields] ]
+      end
+
+      def system_collection?
+        @collection =~ /^system./
+      end
+    end
+  end
+end
+
+Moped::Query.send(:include, Mongoid::QueryCache::Query)
+Moped::Collection.send(:include, Mongoid::QueryCache::Collection)

data/lib/mongoid/query_cache/railtie.rb

@@ -0,0 +1,7 @@
+module Mongoid::QueryCache
+  class Railtie < Rails::Railtie
+    initializer 'mongoid.query_cache.insert_middleware' do |app|
+      app.config.middleware.use 'Mongoid::QueryCache::Middleware'
+    end
+  end
+end

data/lib/mongoid/query_cache/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module QueryCache
+    VERSION = '0.0.1'
+  end
+end

data/mongoid-query_cache.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mongoid/query_cache/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'mongoid-query_cache'
+  spec.version       = Mongoid::QueryCache::VERSION
+  spec.authors       = ['Philip Claren']
+  spec.email         = ['philip.claren@googlemail.com']
+  spec.summary       = 'Backport of the Mongoid 4 QueryCache for Mongoid 3.'
+  spec.description   = 'Backport of the Mongoid 4 QueryCache for Mongoid 3.'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake', '~> 10.3'
+  spec.add_development_dependency 'rspec', '~> 2.13'
+
+  spec.add_dependency 'mongoid', '~> 3.1'
+end

data/spec/config/mongoid.yml

@@ -0,0 +1,8 @@
+test:
+  sessions:
+    default:
+      database: mongoid_query_cache_test
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong

data/spec/mongoid_query_cache_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+class Band
+  include Mongoid::Document
+end
+
+describe Mongoid::QueryCache do
+
+  around do |spec|
+    Mongoid::QueryCache.clear_cache
+    Mongoid::QueryCache.cache { spec.run }
+  end
+
+  context 'when inserting an index' do
+
+    it 'does not cache the query' do
+      Mongoid::QueryCache.should_receive(:cache_table).never
+      Band.collection.indexes.create(name: 1)
+    end
+  end
+end
+
+describe Mongoid::QueryCache::Middleware do
+
+  let :middleware do
+    Mongoid::QueryCache::Middleware.new(app)
+  end
+
+  context 'when not touching mongoid on the app' do
+
+    let(:app) do
+      ->(env) { @enabled = Mongoid::QueryCache.enabled?; [200, env, "app"] }
+    end
+
+    it 'returns success' do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    it 'enableds the query cache' do
+      middleware.call({})
+      expect(@enabled).to be true
+    end
+  end
+
+  context 'when querying on the app' do
+
+    let(:app) do
+      ->(env) {
+        Band.all.to_a
+        [200, env, "app"]
+      }
+    end
+
+    it 'returns success' do
+      code, _ = middleware.call({})
+      expect(code).to eq(200)
+    end
+
+    it 'cleans the query cache after reponds' do
+      middleware.call({})
+      expect(Mongoid::QueryCache.cache_table).to be_empty
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+# Configure Rails Environment
+ENV['RACK_ENV'] = 'test'
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'mongoid'
+require 'mongoid/query_cache'
+
+Mongoid.load!(File.expand_path('../../spec/config/mongoid.yml', __FILE__))
+
+
+RSpec.configure do |config|
+  # some (optional) config here
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-query_cache
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Philip Claren
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Backport of the Mongoid 4 QueryCache for Mongoid 3.
+email:
+- philip.claren@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/mongoid/query_cache.rb
+- lib/mongoid/query_cache/railtie.rb
+- lib/mongoid/query_cache/version.rb
+- mongoid-query_cache.gemspec
+- spec/config/mongoid.yml
+- spec/mongoid_query_cache_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Backport of the Mongoid 4 QueryCache for Mongoid 3.
+test_files:
+- spec/config/mongoid.yml
+- spec/mongoid_query_cache_spec.rb
+- spec/spec_helper.rb