method_cache 0.6.3 → 0.6.4

data/README.rdoc

@@ -33,10 +33,8 @@ Ruby.
 
 == Install:
 
-  sudo gem install ninjudd-memcache -s http://gems.github.com
-  sudo gem install ninjudd-cache_version -s http://gems.github.com
-  sudo gem install ninjudd-method_cache -s http://gems.github.com
+  gem install method_cache
 
 == License:
 
-Copyright (c) 2009 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 @@
 --- 
 :build: 
-:patch: 3
-:major: 0
 :minor: 6
+:patch: 4
+:major: 0

data/lib/method_cache/proxy.rb

@@ -1,10 +1,14 @@
+require 'digest/sha1'
+
 module MethodCache
   class Proxy
     attr_reader :method_name, :opts, :args, :target
+    NULL = 'NULL'
 
     def initialize(method_name, opts)
+      opts[:cache] ||= :counters if opts[:counter]
       @method_name = method_name
-      @opts        = opts
+      @opts        = opts      
     end
 
     def bind(target, args)
@@ -46,11 +50,12 @@ module MethodCache
     end
 
     def value
-      value = cache[key] unless MethodCache.disabled?
+      value = opts[:counter] ? cache.count(key) : cache[key] unless MethodCache.disabled?
       value = nil unless valid?(:load, value)
 
       if value.nil?
         value = target.send(method_name_without_caching, *args)
+        raise "non-integer value returned by counter method" if opts[:counter] and not value.kind_of?(Fixnum)
         write_to_cache(key, value) if valid?(:save, value)
       end
 
@@ -62,7 +67,6 @@ module MethodCache
       end
     end
 
-    NULL = 'NULL'
     def method_with_caching
       proxy = self # Need access to the proxy in the closure.
 
@@ -71,6 +75,18 @@ module MethodCache
       end
     end
 
+    def counter_method(method_name)
+      proxy = self # Need access to the proxy in the closure.
+
+      lambda do |*args|
+        if args.last.kind_of?(Hash) and args.last.keys == [:by]
+          amount = args.last[:by]
+          args.pop
+        end
+        proxy.bind(self, args).send(method_name, amount || 1)
+      end
+    end
+
     def method_name_without_caching
       @method_name_without_caching ||= begin
         base_name, punctuation = method_name.to_s.sub(/([?!=])$/, ''), $1
@@ -100,6 +116,7 @@ module MethodCache
           object_key(arg)
         end.join('|')
         @key = ['m', version, arg_string].compact.join('|')
+        @key = "m|#{Digest::SHA1.hexdigest(@key)}" if @key.length > 250
       end
       @key
     end
@@ -122,8 +139,8 @@ module MethodCache
       if opts[name].kind_of?(Proc)
         proc = opts[name].bind(target)
         case proc.arity
-        when 0: proc.call()
-        when 1: proc.call(value)
+        when 0 then proc.call()
+        when 1 then proc.call(value)
         else
           proc.call(value, *args)
         end
@@ -134,25 +151,38 @@ module MethodCache
 
     def write_to_cache(key, value)
       if cache.kind_of?(Hash)
-        raise 'expiry not permitted when cache is a Hash' if opts[:expiry]
+        raise 'expiry not permitted when cache is a Hash'        if opts[:expiry]
+        raise 'counter cache not permitted when cache is a Hash' if opts[:counter]
         cache[key] = value
+      elsif opts[:counter]
+        cache.write(key, value.to_s, :expiry => expiry(value))
       else
-        value  = value.nil? ? NULL : value
+        value = value.nil? ? NULL : value
         cache.set(key, value, :expiry => expiry(value))
       end
     end
 
+    def increment(amount)
+      raise "cannot increment non-counter method" unless opts[:counter]
+      cache.incr(key, amount)
+    end
+
+    def decrement(amount)
+      raise "cannot decrement non-counter method" unless opts[:counter]
+      cache.decr(key, amount)
+    end
+
     def object_key(arg)
       return "#{class_key(arg.class)}-#{arg.string_hash}" if arg.respond_to?(:string_hash)
 
       case arg
-      when NilClass      : 'nil'
-      when TrueClass     : 'true'
-      when FalseClass    : 'false'
-      when Numeric       : arg.to_s
-      when Symbol        : ":#{arg}"
-      when String        : "'#{arg}'"
-      when Class, Module : class_key(arg)
+      when NilClass      then 'nil'
+      when TrueClass     then 'true'
+      when FalseClass    then 'false'
+      when Numeric       then arg.to_s
+      when Symbol        then ":#{arg}"
+      when String        then "'#{arg}'"
+      when Class, Module then class_key(arg)
       when Hash
         '{' + arg.collect {|key, value| "#{object_key(key)}=#{object_key(value)}"}.sort.join(',') + '}'
       when Array

data/lib/method_cache.rb

@@ -17,13 +17,15 @@ module MethodCache
       end
 
       cached_instance_methods[method_name] = nil
-      begin
+      if method_defined?(method_name) or private_method_defined?(method_name)
+        if proxy.opts[:counter]
+          define_method "increment_#{method_name}", proxy.counter_method(:increment)
+          define_method "decrement_#{method_name}", proxy.counter_method(:decrement)
+        end
+
         # Replace instance method.
         alias_method proxy.method_name_without_caching, method_name
         define_method method_name, proxy.method_with_caching
-      rescue NameError => e
-        # The method has not been defined yet. We will alias it in method_added.
-        # pp e, e.backtrace
       end
       cached_instance_methods[method_name] = proxy
 
@@ -47,19 +49,28 @@ module MethodCache
 
     method_name = method_name.to_sym
     cached_class_methods[method_name] = nil
-    begin
-      # Replace class method.
+    if class_method_defined?(method_name)
       (class << self; self; end).module_eval do
+        if proxy.opts[:counter]
+          define_method "increment_#{method_name}", proxy.counter_method(:increment)
+          define_method "decrement_#{method_name}", proxy.counter_method(:decrement)
+        end
+
+        # Replace class method.
         alias_method proxy.method_name_without_caching, method_name
         define_method method_name, proxy.method_with_caching
       end
-    rescue NameError => e
-      # The method has not been defined yet. We will alias it in singleton_method_added.
-      # pp e, e.backtrace
     end
     cached_class_methods[method_name] = proxy
   end
 
+  def class_method_defined?(method_name)
+    method(method_name)
+    true
+  rescue NameError
+    false
+  end
+
   def self.default_cache
     @default_cache ||= {}
   end

data/method_cache.gemspec

@@ -1,47 +1,41 @@
 # Generated by jeweler
 # DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{method_cache}
-  s.version = "0.6.3"
+  s.version = "0.6.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Justin Balthrop"]
-  s.date = %q{2010-04-13}
+  s.date = %q{2011-08-23}
   s.description = %q{Simple memcache-based memoization library for Ruby}
   s.email = %q{code@justinbalthrop.com}
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+    "README.rdoc"
   ]
   s.files = [
     "LICENSE",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION.yml",
-     "lib/method_cache.rb",
-     "lib/method_cache/proxy.rb",
-     "method_cache.gemspec",
-     "test/method_cache_test.rb",
-     "test/test_helper.rb"
+    "README.rdoc",
+    "Rakefile",
+    "VERSION.yml",
+    "lib/method_cache.rb",
+    "lib/method_cache/proxy.rb",
+    "method_cache.gemspec",
+    "test/method_cache_test.rb",
+    "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/ninjudd/method_cache}
-  s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.5.2}
   s.summary = %q{Simple memcache-based memoization library for Ruby}
-  s.test_files = [
-    "test/method_cache_test.rb",
-     "test/test_helper.rb"
-  ]
 
   if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
 
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<memcache>, [">= 1.0.0"])
     else
       s.add_dependency(%q<memcache>, [">= 1.0.0"])

data/test/method_cache_test.rb

@@ -20,6 +20,17 @@ class Foo
     @@i += i
   end
   cache_method :baz, :cache => :remote
+
+  cache_class_method :bap
+  def self.bap(i)
+    @i ||= 0
+    @i  += i
+  end
+  
+  cache_class_method :zap, :counter => true
+  def self.zap
+    0
+  end
 end
 
 module Bar
@@ -30,10 +41,16 @@ module Bar
     @i ||= 0
     @i  += i
   end
+
+  cache_method :foo_count, :counter => true, :cache => :default
+  def foo_count(key)
+    100
+  end
 end
 
 class Baz
   include Bar
+  extend  Bar
 end
 
 class TestMethodCache < Test::Unit::TestCase
@@ -84,6 +101,13 @@ class TestMethodCache < Test::Unit::TestCase
     assert b2 == a.baz(2)
   end
 
+  should 'cache class methods' do
+    assert_equal 10, Foo.bap(10)
+    assert_equal 23, Foo.bap(13)
+    assert_equal 10, Foo.bap(10)
+    assert_equal 23, Foo.bap(13)
+  end
+
   should 'cache methods for mixins' do
     a = Baz.new
 
@@ -93,6 +117,13 @@ class TestMethodCache < Test::Unit::TestCase
     assert_equal 3, a.foo(2)
   end
 
+  should 'cache class methods for mixins' do
+    assert_equal 1, Baz.foo(1)
+    assert_equal 1, Baz.foo(1)
+    assert_equal 3, Baz.foo(2)
+    assert_equal 3, Baz.foo(2)
+  end
+
   should 'invalidate cached method' do
     a = Foo.new
 
@@ -105,6 +136,29 @@ class TestMethodCache < Test::Unit::TestCase
     assert_equal 3, a.foo(2)
   end
 
+  should 'cache counters' do
+    b = Baz.new
+
+    assert_equal 100, b.foo_count(:bar)
+    b.increment_foo_count(:bar, :by => 42)
+    assert_equal 142, b.foo_count(:bar)
+    b.decrement_foo_count(:bar, :by => 99)
+    assert_equal 43, b.foo_count(:bar)
+    b.increment_foo_count(:bar)
+    assert_equal 44, b.foo_count(:bar)
+
+    assert_equal 100, b.foo_count(:baz)
+    b.increment_foo_count(:baz)
+    assert_equal 101, b.foo_count(:baz)
+    assert_equal 44,  b.foo_count(:bar) # make sure :bar wasn't affected
+
+    assert_equal 0, Foo.zap
+    Foo.increment_zap(:by => 3)
+    assert_equal 3, Foo.zap
+    Foo.decrement_zap
+    assert_equal 2, Foo.zap
+  end
+
   should 'use consistent local keys' do
     a = Foo.new
     o = Object.new

metadata

@@ -1,7 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: method_cache
 version: !ruby/object:Gem::Version 
-  version: 0.6.3
+  hash: 15
+  prerelease: 
+  segments: 
+  - 0
+  - 6
+  - 4
+  version: 0.6.4
 platform: ruby
 authors: 
 - Justin Balthrop
@@ -9,19 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-13 00:00:00 -07:00
+date: 2011-08-23 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: memcache
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
         version: 1.0.0
-    version: 
+  type: :runtime
+  version_requirements: *id001
 description: Simple memcache-based memoization library for Ruby
 email: code@justinbalthrop.com
 executables: []
@@ -46,29 +58,34 @@ homepage: http://github.com/ninjudd/method_cache
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Simple memcache-based memoization library for Ruby
-test_files: 
-- test/method_cache_test.rb
-- test/test_helper.rb
+test_files: []
+