mongoid-store 0.4.3 → 0.4.4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NDAwODkyODM3MGQ3MmM0OTNkZmZlMjE0MzY1YWUzM2YwMzJiYTE1ZQ==
+    ZDRiNmQyNzFhZDU3YTcxNWVmODY1Zjc2YTczMzUyYTkzYjE3MTdiMA==
   data.tar.gz: !binary |-
-    MmVlNWVhYTk2NGRlOWFkYTdjMTk3NTYyY2M0OTI2MmJlZTU0YTg1Ng==
+    YWE0ZjVkNDE4OWNiMWRiNmRmNzFmZTk4MGViN2RhMjdiNDE3NmE0ZA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YTNjZDNiNTkxYjIzZTFiMzNmYjFiZjEyODhhMDkxODYzYjlkOTk5ZjdjNjgx
-    YzFiZDRiMTAwMzAyOTVkOTk3MmFlY2JkMTQxZDA0YzI3OTVhZDBiN2RlYzg4
-    OTBmYjc0ODBhN2MyMDYyMjdlOWY3NGY0OTBiZTEwYWQ5NjZhZjI=
+    NGJlOTUyZGE0NzUyODQyYTQxNTNjYmU0NmM0MjQ1NzJjZjJhNjQxNzc0Y2Zl
+    OWZhNGIyMDAwNDJhNzY4ZmM2Yjg5NjE4ZmFhYjk4OWY0YzJjODM5NWM5OWE2
+    YzZiMzBmMmYxOTJkMzQzMmIyMWE0ODM5MDMzZjlkNjU4MWE4MTQ=
   data.tar.gz: !binary |-
-    ZTExM2Q5ZjhiY2NjOTUwY2UzMGZmMTA3NTUxMzc1OGM3NTA5Mjg4OGZlOTVm
-    ZmEzNDhiNmI3MjRhMjg3NGYxMWRlZjk4YTM1Y2NjMDM1MDI4N2MwOTNiZmQz
-    OTRlMzlkYTY3ZTg0MDRhMmE3ZjFhYjU5OGU3Zjk4ZTdjNjMyNWU=
+    Njk5MTY0NTVmNDQ4M2YzYzJjMWYzYWU0MWIwZDYxYzM3NmUzNTM5MWU2YTYz
+    OGZkMDQyODI5Y2M5OGJlMmI4YzBiNjk1MTllMTBiYmUzZmQzNzE5MzJmMjM1
+    YTQ0ZmJmMTZhNjJiZGUzNGQ5OGJmNGJiMjAxMDAyOWQzODcyZDI=

data/README.md

@@ -7,6 +7,23 @@ gem by Andre Meij (see his orginial LICENSE)
 unlike the the original gem this version works with both rails3 and rails4,
 and handles any object in any encoding (remember mongo is utf8 only)
 
+Why?
+----
+
+mongoid-store is not as fast as redis-store.  in my tests inserting 10_000
+random strings takes about 6 seconds for mongoid-store and 2 for redis-store.
+
+in our (@dojo4) applications we use mongoid-store to reduce the number of
+requirements when applications are young: avoiding the need to setup *two*
+highly avaiable RAM devouring db services (redis + mongo).  instead we can
+simply configure our applications to use a solid mongo service like
+http://www.objectrocket.com/ - which provides a highly available and
+automatically scalable mongo layer, two app servers, a load balancer, are
+we're pretty set.  we also like to put all our images in mongo using
+mongoid-grid_fs (or s3) and even our background jobs so, at the end of the
+day, mongoid-store is aimed at keeping new application deployment simple and
+relatively dependency free.
+
 
 
 Supports
@@ -58,3 +75,10 @@ Using MongoidStore with rails is as easy as:
 
   Rails.cache.write(:key, :val)
 ```
+
+References
+----------
+
+http://www.slideshare.net/mongodb/mongodb-as-a-fast-and-queryable-cache
+http://stackoverflow.com/questions/10317732/why-use-redis-instead-of-mongodb-for-caching
+

data/lib/active_support/cache/mongoid_store.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+#
+require 'mongoid'
+require 'active_support'
+
+module ActiveSupport
+  module Cache
+    class MongoidStore < Store
+      attr_reader :collection_name
+
+      def initialize(options = {})
+        @collection_name = options[:collection] || :rails_cache
+        options[:expires_in] ||= 1.hour
+        super(options)
+      end
+
+      def clear(options = nil)
+        collection.find.remove_all
+      end
+
+      def cleanup(options = nil)
+        options = merged_options(options)
+        collection.find(expires_at: {'$lt' => Time.now.utc.to_i}).remove_all
+      end
+
+      def delete_matched(matcher, options = nil)
+        options = merged_options(options)
+        collection.find(_id: key_matcher(matcher, options)).remove_all
+      end
+
+      def delete_entry(key, options = nil)
+        collection.find(_id: key).remove
+      end
+
+    protected
+
+      def write_entry(key, entry, options)
+        data = Entry.data_for(entry)
+        expires_at = entry.expires_at.to_i
+        created_at = Time.now.utc.to_i
+
+        collection.find(_id: key).upsert(_id: key, data: data, expires_at: expires_at, created_at: created_at)
+
+        entry
+      end
+
+      def read_entry(key, options = {})
+        expires_at = Time.now.utc.to_i
+        doc = collection.find(_id: key, expires_at: {'$gt' => expires_at}).first
+
+        Entry.for(doc) if doc
+      end
+
+    # this class exists to normalize between rails3 and rails4, but also to
+    # repair totally broken interfaces in rails - especially in rails3 - that
+    # result in lots of extra serialization/deserialzation in a class which is
+    # supposed to be FAST
+    #
+      class Entry < ::ActiveSupport::Cache::Entry
+        def Entry.is_rails3?
+          unless defined?(@is_rails3)
+            @is_rails3 = new(nil).instance_variable_defined?('@value')
+          end
+
+          @is_rails3
+        end
+
+      # extract marshaled data from a cache entry without doing unnecessary
+      # marshal round trips.  rails3 will have either a nil or pre-marshaled
+      # @value whereas rails4 will have either a marshaled or un-marshaled @v.
+      # in both cases we want to avoid calling the silly 'value' accessor
+      # since this will cause a potential Marshal.load call and require us to
+      # make a subsequent Marshal.dump call which is SLOOOWWW.
+      #
+        if is_rails3?
+
+          def Entry.data_for(entry)
+            value = entry.instance_variable_get('@value')
+            marshaled = value.nil? ? Marshal.dump(value) : value
+            Moped::BSON::Binary.new(:generic, marshaled)
+          end
+
+        else
+
+          def Entry.data_for(entry)
+            v = entry.instance_variable_get('@v')
+            marshaled = entry.send('compressed?') ? v : entry.send('compress', v)
+            Moped::BSON::Binary.new(:generic, marshaled)
+          end
+
+        end
+
+      # the intializer for rails' default Entry class will go ahead and
+      # perform and extraneous Marshal.dump on the data we just got from the
+      # db even though we don't need it here.  rails3 has a factory to avoid
+      # this but rails4 does not so we just build the object we want and
+      # ensure to avoid any unnecessary calls to Marshal.dump/load...  sigh.
+      #
+        if is_rails3?
+
+          def Entry.for(doc)
+            data = doc['data'].to_s
+            value = Marshal.load(data)
+            created_at = doc['created_at'].to_f
+
+            allocate.tap do |entry|
+              entry.instance_variable_set(:@value, value)
+              entry.instance_variable_set(:@compressed, false)
+              entry.instance_variable_set(:@created_at, created_at)
+            end
+          end
+
+        else
+
+          def Entry.for(doc)
+            data = doc['data'].to_s
+            value = Marshal.load(data)
+            created_at = doc['created_at'].to_f
+
+            allocate.tap do |entry|
+              entry.instance_variable_set(:@v, value)
+              entry.instance_variable_set(:@c, false)
+            end
+          end
+
+        end
+
+        def value
+          Entry.is_rails3? ? @value : @v
+        end
+
+        def raw_value
+          Entry.is_rails3? ? @value : @v
+        end
+      end
+
+    private
+
+      def collection
+        Mongoid.session(:default)[collection_name]
+      end
+    end
+  end
+end

data/lib/mongoid-store/version.rb

@@ -1,3 +1,3 @@
 module MongoidStore
-  Version = '0.4.3'
+  Version = '0.4.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-store
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - Ara Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-11 00:00:00.000000000 Z
+date: 2013-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -54,10 +54,10 @@ files:
 - Rakefile
 - a.rb
 - lib/active_support/cache/mongoid-store.rb
+- lib/active_support/cache/mongoid_store.rb
 - lib/mongoid-store.rb
 - lib/mongoid-store/version.rb
 - mongoid-store.gemspec
-- pkg/mongoid-store-0.4.2.gem
 - spec/helper.rb
 - spec/mongoid-store_spec.rb
 - spec/mongoid.yml