jashmenn-method_cache 0.7.1.0 → 0.8.0.0

data/README.rdoc

@@ -6,7 +6,7 @@ Ruby.
 == Usage:
 
   class Foo
-    extend MethodCache
+    extend Ifttt::MethodCache
 
     cache_method :bar
     def bar
@@ -35,6 +35,21 @@ Ruby.
 
   gem install method_cache
 
+== About this fork:
+
+Forked for ifttt
+
+=== About instances
+
+*This is important, please make sure you understand it*
+
+By default this method will qualify the key based on an instance hash. 
+
+That is, by default, every instance will cache to a *different* key, even given the same arguments. (This makes sense, technically all the instance variables of an object are arguments and thus the output could be different.)
+
+If you want all instance to share a cache for a given set of arguments, first, consider making this a class method and calling that. Second, if you absolutely have to have it be an instance method, define #string_hash on your method and, if that method is consistent, all the instances will share a hash key for a given set of arguments.
+
+
 == License:
 
-Copyright (c) 2010 Justin Balthrop, Geni.com; Published under The MIT License, see LICENSE
+Copyright (c) 2010 Justin Balthrop, Geni.com; Published under The MIT License, see LICENSE

data/VERSION.yml

@@ -1,5 +1,5 @@
 ---
 :major: 0
-:minor: 7
-:patch: 1
-:build: 0
+:minor: 8 
+:patch: 0
+:build: 0 

data/lib/method_cache.rb

@@ -1,9 +1,12 @@
 $:.unshift(File.dirname(__FILE__))
+require 'pp'
 require 'method_cache/proxy'
 
+module Eigenjoy
 module MethodCache
   def cache_method(method_name, opts = {})
     method_name = method_name.to_sym
+    (opts[:version] ||= self.to_s) if self.class == Module # maybe in other cases too?
     proxy = opts.kind_of?(Proxy) ? opts : Proxy.new(method_name, opts)
 
     if self.class == Class
@@ -29,6 +32,9 @@ module MethodCache
 
     elsif self.class == Module
       # We will alias all methods when the module is mixed-in.
+      # include(InvalidationMethods)
+      # pp [:module, self, cached_module_methods]
+
       extend(ModuleAdded) if cached_module_methods.empty?
       cached_module_methods[method_name.to_sym] = proxy
     end
@@ -73,11 +79,21 @@ module MethodCache
     @default_cache ||= {}
   end
 
+  def get_ancestors
+    ancestors = if self.respond_to?(:ancestors)
+                  self.ancestors
+                else
+                  self.class.ancestors
+                end
+    ancestors + extended_modules
+  end
+
   def cached_instance_methods(method_name = nil)
     if method_name
       method_name = method_name.to_sym
-      ancestors.each do |klass|
-        next unless klass.kind_of?(MethodCache)
+      get_ancestors.each do |klass|
+        next unless klass.kind_of?(Eigenjoy::MethodCache)
+        # pp [:found, method_name, klass, klass.cached_instance_methods]
         proxy = klass.cached_instance_methods[method_name]
         return proxy if proxy
       end
@@ -90,8 +106,8 @@ module MethodCache
   def cached_class_methods(method_name = nil)
     if method_name
       method_name = method_name.to_sym
-      ancestors.each do |klass|
-        next unless klass.kind_of?(MethodCache)
+      get_ancestors.each do |klass|
+        next unless klass.kind_of?(Eigenjoy::MethodCache)
         proxy = klass.cached_class_methods[method_name]
         return proxy if proxy
       end
@@ -134,16 +150,25 @@ module MethodCache
     end
 
     def without_method_cache(&block)
-      MethodCache.disable(&block)
+      Eigenjoy::MethodCache.disable(&block)
     end
 
   private
 
+    def extended_modules
+      (class << self; self end).included_modules
+    end
+
     def cached_method(method_name, args)
+      # pp [:cached_method, method_name, self, self.get_ancestors, self.class.respond_to?(:cached_instance_methods), extended_modules]
       if self.kind_of?(Class) or self.kind_of?(Module)
         proxy = cached_class_methods(method_name)
       else
-        proxy = self.class.send(:cached_instance_methods, method_name)
+        if self.class.respond_to?(:cached_instance_methods)
+          proxy = self.class.send(:cached_instance_methods, method_name)
+        else
+          proxy = cached_instance_methods(method_name)
+        end
       end
       raise "method '#{method_name}' not cached" unless proxy
       proxy.bind(self, args)
@@ -170,17 +195,18 @@ module MethodCache
 
   module ModuleAdded
     def extended(mod)
-      mod.extend(MethodCache)
+      mod.extend(Eigenjoy::MethodCache)
       cached_module_methods.each do |method_name, proxy|
         mod.cache_class_method(method_name, proxy)
       end
     end
 
     def included(mod)
-      mod.extend(MethodCache)
+      mod.extend(Eigenjoy::MethodCache)
       cached_module_methods.each do |method_name, proxy|
         mod.cache_method(method_name, proxy)
       end
     end
   end
 end
+end

data/lib/method_cache/proxy.rb

@@ -4,6 +4,7 @@ class Object
   def metaclass; class << self; self; end; end
 end
 
+module Eigenjoy
 module MethodCache
   class Proxy
     attr_reader :method_name, :opts, :args, :target
@@ -54,7 +55,7 @@ module MethodCache
     end
 
     def value
-      value = opts[:counter] ? cache.count(key) : cache[key] unless MethodCache.disabled?
+      value = opts[:counter] ? cache.count(key) : cache[key] unless Eigenjoy::MethodCache.disabled?
       value = nil unless valid?(:load, value)
 
       if value.nil?
@@ -100,7 +101,7 @@ module MethodCache
 
     def cache
       if @cache.nil?
-        @cache = opts[:cache] || MethodCache.default_cache
+        @cache = opts[:cache] || Eigenjoy::MethodCache.default_cache
         @cache = Memcache.pool[@cache] if @cache.kind_of?(Symbol)
         if not @cache.respond_to?(:[]) and @cache.respond_to?(:get)
           @cache.metaclass.module_eval do
@@ -129,6 +130,7 @@ module MethodCache
         @key = ['m', version, arg_string].compact.join('|')
         @key = "m|#{Digest::SHA1.hexdigest(@key)}" if @key.length > 250
       end
+      pp @key
       @key
     end
 
@@ -191,7 +193,7 @@ module MethodCache
     end
 
     def object_key(arg)
-      return "#{class_key(arg.class)}-#{arg.string_hash}" if arg.respond_to?(:string_hash)
+      return "#{class_key(arg.class)}-#{arg.cache_key_qualifier}" if arg.respond_to?(:cache_key_qualifier)
 
       case arg
       when NilClass      then 'nil'
@@ -208,6 +210,8 @@ module MethodCache
       when defined?(ActiveRecord::Base) && ActiveRecord::Base
         "#{class_key(arg.class)}-#{arg.id}"
       else
+        # such a tricky case. if you want all instances to share the same value then implement #cache_key_qualifier
+        # otherwise this cache is instance specific
         hash = local? ? arg.hash : Marshal.dump(arg).hash
         "#{class_key(arg.class)}-#{hash}"
       end
@@ -218,3 +222,4 @@ module MethodCache
     end
   end
 end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jashmenn-method_cache
 version: !ruby/object:Gem::Version
-  version: 0.7.1.0
+  version: 0.8.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-17 00:00:00.000000000Z
+date: 2012-02-22 00:00:00.000000000Z
 dependencies: []
 description: Simple memcache-based memoization library for Ruby
 email: code@justinbalthrop.com