my_stuff-cache 0.0.1

data/lib/my_stuff/cache/base.rb

@@ -0,0 +1,85 @@
+# Copyright 2011-present Fred Emmott. All Rights Reserved.
+
+module MyStuff
+  module Cache
+    # Base implementation.
+    #
+    # You probably want a subclass instead:
+    # - MyStuff::Cache::NullCache (not likely)
+    # - MyStuff::Cache::MemoryCache
+    # - MyStuff::Cache::MemcachedCache
+    class Base
+      # Try to get ids from cache, falling back to the given block.
+      #
+      # See #get_with_multi_fallback for documentation.
+      #
+      # Unlike get_with_multi_fallback, fallback gets called once for each
+      # id. You almost certainly want to use #get_with_multi_fallback
+      # instead.
+      def get_with_fallback ids, key_pattern, options = {}, &fallback
+        get_with_multi_fallback(ids, key_pattern, options) do |ids|
+          result = ids.map{|id| fallback.call(id) }
+          result
+        end
+      end
+
+      # Try to get ids from cache, falling back to to the given block.
+      #
+      # - +ids+ is an array of ids
+      # - +key_pattern+ is a printf string to turn an id into a cache key
+      # 
+      # The following options are supported:
+      # +update_cache+:: If fallback is called, cache the result (default
+      #                  true)
+      # +force_update+:: Fetch from the database, even if there's a value
+      #                  in cache.
+      # +ttl+: Keep fetched values in cache for the specified number of
+      #        seconds. Defaults to forever (0). May be completely ignored.
+      #
+      # The block gets passed the list of ids which missed the cache.
+      def get_with_multi_fallback ids, key_pattern, options = {}, &fallback
+        options = {
+          :update_cache => true,
+        }.merge(options)
+  
+        to_cache = Hash.new
+        if options[:force_update]
+          data = Hash[ids.zip([nil] * ids.size)]
+        else
+          data = Hash[ids.zip(get(ids.map{|x| key_pattern % x}))]
+        end
+        misses = data.select{|k,v| !v}.keys
+        from_fallback = fallback.call(misses)
+        Hash[misses.zip(from_fallback)].each do |k,v|
+          to_cache[key_pattern % k] = v
+          data[k] = v;
+        end
+        set(to_cache) unless to_cache.empty? || !options[:update_cache]
+        ids.map{|k| data[k]}
+      end
+ 
+      # Fetch values from cache.
+      #
+      # Returns an array of values. If a key is not in the cache, nil is
+      # returned instead.
+      #
+      # +keys+ is an array of cache keys.
+      # 
+      # Currently, no options are supported.
+      def get keys, options = {}
+        raise NotImplementedError.new
+      end
+ 
+      # Set values in the cache.
+      #
+      # +values+ is a hash of cache key => values.
+      #
+      # The following options are supported:
+      # +ttl+: Keep fetched values in cache for the specified number of
+      #        seconds. Defaults to forever (0). May be completely ignored.
+      def set values, options = {}
+        raise NotImplementedError.new
+      end
+    end
+  end
+end

data/lib/my_stuff/cache/memcached_cache.rb

@@ -0,0 +1,40 @@
+# Copyright 2011-present Fred Emmott. All Rights Reserved.
+
+autoload :Memcached, 'memcached'
+
+module MyStuff
+  module Cache
+    # Memcache-base cached.
+    #
+    # If you want to use this, you know what it does.
+    class MemcachedCache < MyStuff::Cache::Base
+      # Create an instance of this cache.
+      #
+      # +memcached+ is a Memcached object, provided by the memcached gem.
+      def initialize memcached
+        @mc = memcached
+      end
+
+      def get keys, options = {}
+        begin
+          results = @mc.get(keys) unless keys.empty?
+          keys.map{|k| results[k]}
+        rescue Memcached::Error => e
+          LOG :warning, e
+          [nil] * keys.size
+        end
+      end
+
+      def set values, options = {}
+        options[:ttl] ||= 0
+        begin
+          values.each do |k,v|
+            @mc.set(k, v, options[:ttl])
+          end
+        rescue Memcached::Error => e
+          LOG :warning, e
+        end
+      end
+    end
+  end
+end

data/lib/my_stuff/cache/memory_cache.rb

@@ -0,0 +1,24 @@
+# Copyright 2011-present Fred Emmott. All Rights Reserved.
+
+module MyStuff
+  module Cache
+    # Hash-based cache.
+    #
+    # This will not be shared between instances of the cache - for example,
+    # this means that it won't be shared between all requests in a
+    # Passenger or pool-based setup.
+    class MemoryCache < MyStuff::Cache::Base
+      def initialize
+        @cache = Hash.new
+      end
+
+      def get keys, options = {}
+        keys.map{|key| @cache[key]}
+      end
+
+      def set values, options = {}
+        @cache.merge! values
+      end
+    end
+  end
+end

data/lib/my_stuff/cache/null_cache.rb

@@ -0,0 +1,16 @@
+# Copyright 2011-present Fred Emmott. All Rights Reserved.
+
+module MyStuff
+  module Cache
+    # No-op implementation that implements the API, but does no caching.
+    class NullCache < ::MyStuff::Cache::Base
+      def get keys, options = {}
+        [nil] * keys.size
+      end
+
+      def set keys, options = {}
+        # nop
+      end
+    end
+  end
+end

data/lib/my_stuff/cache.rb

@@ -0,0 +1,22 @@
+# Copyright 2011-present Fred Emmott. All Rights Reserved.
+
+require 'my_stuff/cache/base'
+
+# Code for MyStuff.ws
+module MyStuff
+  # Simplistic caching module.
+  #
+  # You probably want to use ActiveSupport::Cache instead. The two major
+  # advantages of this are in Base#get_with_fallback (compared to
+  # ActiveSupport::Cache::Store#fetch)
+  # - you can specify a key pattern
+  # - it takes a list of IDs, so the implementation might use a multiget
+  #   (MemcachedCache does this)
+  #
+  # See MyStuff::Cache::Base for interface.
+  module Cache
+    autoload :NullCache,      'my_stuff/cache/null_cache'
+    autoload :MemoryCache,    'my_stuff/cache/memory_cache'
+    autoload :MemcachedCache, 'my_stuff/cache/memcached_cache'
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: my_stuff-cache
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Fred Emmott
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-15 00:00:00 Z
+dependencies: []
+
+description: A thin, multi-backend caching library
+email: 
+- mail@fredemmott.co.uk
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/my_stuff/cache/memory_cache.rb
+- lib/my_stuff/cache/base.rb
+- lib/my_stuff/cache/memcached_cache.rb
+- lib/my_stuff/cache/null_cache.rb
+- lib/my_stuff/cache.rb
+homepage: https://github.com/fredemmott/my_stuff-cache
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: MyStuff.ws's caching library
+test_files: []
+