memcache-client-activerecord 0.1.0 → 0.2.0

data/Rakefile

@@ -10,12 +10,16 @@ begin
     gem.email = "m.ishihara@gmail.com"
     gem.homepage = "http://github.com/m4i/memcache-client-activerecord"
     gem.authors = ["ISHIHARA Masaki"]
+    gem.rubyforge_project = "mc-activerecord"
     gem.add_runtime_dependency "activerecord", ">= 2.1"
     gem.add_development_dependency "rspec", ">= 1.2.9"
     gem.add_development_dependency "memcache-client", ">= 1.7.7"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
 rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/generators/cache_model/templates/migration.rb

@@ -4,19 +4,19 @@ class <%= migration_name %> < ActiveRecord::Migration
     when 'MySQL'
       execute(<<-SQL)
         CREATE TABLE `<%= table_name %>` (
-          `key`       VARBINARY(250) NOT NULL PRIMARY KEY,
-          `value`     MEDIUMBLOB NOT NULL,
-          `cas`       INT UNSIGNED NOT NULL,
-          `expire_at` DATETIME
+          `key`    VARBINARY(250) NOT NULL PRIMARY KEY,
+          `value`  MEDIUMBLOB NOT NULL,
+          `cas`    INT UNSIGNED NOT NULL,
+          `expiry` INT
         ) ENGINE=InnoDB
       SQL
 
     else
       create_table :<%= table_name %>, :id => false do |t|
-        t.string   :key,   :null => false, :limit => 250
-        t.binary   :value, :null => false
-        t.integer  :cas,   :null => false
-        t.datetime :expire_at
+        t.string  :key,   :null => false, :limit => 250
+        t.binary  :value, :null => false
+        t.integer :cas,   :null => false
+        t.integer :expiry
       end
       add_index :<%= table_name %>, :key, :unique => true
     end

data/lib/memcache/activerecord.rb

@@ -17,12 +17,13 @@ class MemCache
 
     MAX_KEY_SIZE   = 250
     MAX_VALUE_SIZE = 2 ** 20
+    THIRTY_DAYS    = 60 * 60 * 24 * 30
 
     COLUMN_NAMES = {
-      :key       => 'key',
-      :value     => 'value',
-      :cas       => 'cas',
-      :expire_at => 'expire_at',
+      :key    => 'key',
+      :value  => 'value',
+      :cas    => 'cas',
+      :expiry => 'expiry',
     }
 
     STORED     = "STORED\r\n"
@@ -82,7 +83,7 @@ class MemCache
 
     def get(key, raw = false)
       cache_key = make_cache_key(key)
-      if value = find(cache_key, :value, true, __method__)
+      if value = find(__method__, cache_key, :value, true)
         raw ? value : Marshal.load(value)
       end
     end
@@ -103,7 +104,7 @@ class MemCache
         cache_keys[make_cache_key(key)] = key
         cache_keys
       end
-      rows = find_all(cache_keys.keys, [:key, :value], true, __method__)
+      rows = find_all(__method__, cache_keys.keys, [:key, :value], true)
       rows.inject({}) do |hash, (key, value)|
         hash[cache_keys[key]] = Marshal.load(value)
         hash
@@ -116,9 +117,9 @@ class MemCache
       cache_key = make_cache_key(key)
       value     = value_to_storable(value, raw)
 
-      unless update(cache_key, value, expiry, __method__)
+      unless update(__method__, cache_key, value, expiry)
         # rescue duplicate key error
-        insert(cache_key, value, expiry, __method__) rescue nil
+        insert(__method__, cache_key, value, expiry) rescue nil
       end
 
       STORED unless @no_reply
@@ -128,7 +129,7 @@ class MemCache
       check_readonly!
       raise MemCacheError, 'A block is required' unless block_given?
 
-      result = cas_with_reply(key, expiry, raw, __method__, &block)
+      result = cas_with_reply(__method__, key, expiry, raw, &block)
       result unless @no_reply
     end
 
@@ -138,18 +139,18 @@ class MemCache
       cache_key = make_cache_key(key)
       value     = value_to_storable(value, raw)
 
-      old_value, expire_at =
-        find(cache_key, [:value, :expire_at], false, __method__)
+      old_value, old_expiry =
+        find(__method__, cache_key, [:value, :expiry], false)
 
-      if old_value && available?(expire_at)
+      if old_value && available?(old_expiry)
         NOT_STORED unless @no_reply
 
       else
         if old_value
-          update(cache_key, value, expiry, __method__)
+          update(__method__, cache_key, value, expiry)
         else
           # rescue duplicate key error
-          insert(cache_key, value, expiry, __method__) rescue nil
+          insert(__method__, cache_key, value, expiry) rescue nil
         end
 
         STORED unless @no_reply
@@ -162,7 +163,7 @@ class MemCache
       cache_key = make_cache_key(key)
       value     = value_to_storable(value, raw)
 
-      if update(cache_key, value, expiry, __method__, true)
+      if update(__method__, cache_key, value, expiry, true)
         STORED unless @no_reply
       else
         NOT_STORED unless @no_reply
@@ -192,11 +193,11 @@ class MemCache
       conditions = { COLUMN_NAMES[:key] => cache_key }
 
       if @no_reply
-        _delete(conditions, __method__)
+        _delete(__method__, conditions)
         nil
       else
-        exists = !!find(cache_key, :key, true, __method__)
-        _delete(conditions, __method__)
+        exists = !!find(__method__, cache_key, :key, true)
+        _delete(__method__, conditions)
         exists ? DELETED : NOT_FOUND
       end
     end
@@ -213,7 +214,7 @@ class MemCache
     end
 
     def garbage_collection!
-      _delete(["#{quote_column_name(:expire_at)} <= ?", now], __method__)
+      _delete(__method__, ["#{quote_column_name(:expiry)} <= ?", now])
     end
 
     private
@@ -247,6 +248,14 @@ class MemCache
         value
       end
 
+      def expiry_to_storable(expiry)
+        expiry.zero? ?
+          nil :
+          expiry <= THIRTY_DAYS ?
+            now + expiry :
+            expiry
+      end
+
       def check_value_size!(value)
         if @check_size && value.size > MAX_VALUE_SIZE
           raise MemCacheError,
@@ -254,27 +263,27 @@ class MemCache
         end
       end
 
-      def gets(key, raw, method)
+      def gets(_method_, key, raw)
         cache_key = make_cache_key(key)
-        value, cas = find(cache_key, [:value, :cas], true, method)
+        value, cas = find(_method_, cache_key, [:value, :cas], true)
         if cas
           [raw ? value : Marshal.load(value), cas]
         end
       end
 
-      def cas_with_reply(key, expiry, raw, method, &block)
-        value, cas = gets(key, raw, method)
+      def cas_with_reply(_method_, key, expiry, raw, &block)
+        value, cas = gets(_method_, key, raw)
         if cas
           cache_key = make_cache_key(key)
           value     = value_to_storable(yield(value), raw)
 
-          update(cache_key, value, expiry, method, true, cas) ?
+          update(_method_, cache_key, value, expiry, true, cas) ?
             STORED : EXISTS
         end
       end
 
       # TODO: check value size
-      def append_or_prepend(method, key, value)
+      def append_or_prepend(_method_, key, value)
         check_readonly!
 
         cache_key = make_cache_key(key)
@@ -283,33 +292,33 @@ class MemCache
         old = quote_column_name(:value)
         new = quote_value(:value, value)
         pairs = {
-          :value => concat_sql(*(method == :append ? [old, new] : [new, old]))
+          :value => concat_sql(*(_method_ == :append ? [old, new] : [new, old]))
         }
 
         affected_rows = @ar.connection.update(
           update_sql(cache_key, pairs, true, nil),
-          sql_name(method)
+          sql_name(_method_)
         )
 
         affected_rows > 0 ? STORED : NOT_STORED unless @no_reply
       end
 
-      def incr_or_decl(method, key, amount)
+      def incr_or_decl(_method_, key, amount)
         check_readonly!
 
         unless /\A\s*\d+\s*\z/ =~ amount.to_s
           raise MemCacheError, 'invalid numeric delta argument'
         end
-        amount = method == :incr ? amount.to_i : - amount.to_i
+        amount = _method_ == :incr ? amount.to_i : - amount.to_i
 
         value = nil
 
         count = 0
         begin
           count += 1
-          raise MemCacheError, "cannot #{method}" if count > 10
+          raise MemCacheError, "cannot #{_method_}" if count > 10
 
-          result = cas_with_reply(key, nil, true, method) do |old_value|
+          result = cas_with_reply(_method_, key, nil, true) do |old_value|
             unless /\A\s*\d+\s*\z/ =~old_value
               raise MemCacheError,
                 'cannot increment or decrement non-numeric value'
@@ -324,7 +333,7 @@ class MemCache
         raise unless @no_reply
       end
 
-      def find(cache_key, column_keys, only_available, method)
+      def find(_method_, cache_key, column_keys, only_available)
         result = @ar.connection.send(
           column_keys.is_a?(Array) ? :select_one : :select_value,
           select_sql(
@@ -332,7 +341,7 @@ class MemCache
             quote_column_name(*Array(column_keys)),
             only_available
           ),
-          sql_name(method)
+          sql_name(_method_)
         )
 
         (result && column_keys.is_a?(Array)) ?
@@ -340,7 +349,7 @@ class MemCache
           result
       end
 
-      def find_all(cache_keys, column_keys, only_available, method)
+      def find_all(_method_, cache_keys, column_keys, only_available)
         return [] if cache_keys.empty?
 
         result = @ar.connection.send(
@@ -350,7 +359,7 @@ class MemCache
             quote_column_name(*Array(column_keys)),
             only_available
           ),
-          sql_name(method)
+          sql_name(_method_)
         )
 
         column_keys.is_a?(Array) ?
@@ -358,7 +367,7 @@ class MemCache
           result
       end
 
-      def insert(cache_key, value, expiry, method)
+      def insert(_method_, cache_key, value, expiry)
         attributes = attributes_for_update(value, expiry).merge(
           :key => cache_key,
           :cas => 0
@@ -374,11 +383,11 @@ class MemCache
           "INSERT INTO #{@ar.quoted_table_name}" +
           " (#{quote_column_name(*column_keys)})" +
           " VALUES(#{quoted_values.join(', ')})",
-          sql_name(method)
+          sql_name(_method_)
         )
       end
 
-      def update(cache_key, value, expiry, method, only_available = false, cas = nil)
+      def update(_method_, cache_key, value, expiry, only_available = false, cas = nil)
         attributes = attributes_for_update(value, expiry)
 
         pairs = attributes.keys.inject({}) do |pairs, column_key|
@@ -388,32 +397,32 @@ class MemCache
 
         @ar.connection.update(
           update_sql(cache_key, pairs, only_available, cas),
-          sql_name(method)
+          sql_name(_method_)
         ) > 0
       end
 
-      def _delete(conditions, method)
+      def _delete(_method_, conditions)
         @ar.connection.execute(
           "DELETE FROM #{@ar.quoted_table_name}" +
           " WHERE #{@ar.send(:sanitize_sql, conditions)}",
-          sql_name(method)
+          sql_name(_method_)
         )
       end
 
-      def truncate(method)
+      def truncate(_method_)
         sql = case @ar.connection.adapter_name
           when 'SQLite'
             "DELETE FROM #{@ar.quoted_table_name}"
           else
             "TRUNCATE TABLE #{@ar.quoted_table_name}"
           end
-        @ar.connection.execute(sql, sql_name(method))
+        @ar.connection.execute(sql, sql_name(_method_))
       end
 
       def attributes_for_update(value, expiry)
         attributes = { :value => value }
         unless expiry.nil?
-          attributes.update(:expire_at => expiry.zero? ? nil : now(expiry))
+          attributes.update(:expiry => expiry_to_storable(expiry))
         end
         attributes
       end
@@ -449,8 +458,8 @@ class MemCache
 
         if only_available
           conditions.first << ' AND (' +
-            "#{quote_column_name(:expire_at)} IS NULL" +
-            " OR #{quote_column_name(:expire_at)} > ?" +
+            "#{quote_column_name(:expiry)} IS NULL" +
+            " OR #{quote_column_name(:expiry)} > ?" +
           ')'
           conditions << now
         end
@@ -467,12 +476,12 @@ class MemCache
         end
       end
 
-      def sql_name(method)
-        "#{self.class.name}##{method}"
+      def sql_name(_method_)
+        "#{self.class.name}##{_method_}"
       end
 
-      def now(delay = 0)
-        Time.now + delay
+      def now
+        Time.now.to_i
       end
 
       def quote_column_name(*column_keys)
@@ -486,12 +495,8 @@ class MemCache
         @ar.connection.quote(value, @ar.columns_hash[COLUMN_NAMES[column_key]])
       end
 
-      def available?(expire_at)
-        expire_at.nil? || now < to_time(expire_at)
-      end
-
-      def to_time(expire_at)
-        @ar.columns_hash[COLUMN_NAMES[:expire_at]].type_cast(expire_at)
+      def available?(expiry)
+        expiry.nil? || now < expiry.to_i
       end
   end
 

data/spec/memcache/activerecord_spec.rb

@@ -138,6 +138,27 @@ describe "#{adapter}:" do
           caches.same(:get, 'FOO').should == 2
         end
 
+        it 'should support a number of seconds starting from current time' do
+          [
+            1,
+            MemCache::ActiveRecord::THIRTY_DAYS,
+          ].each do |expiry|
+            dbcache.set('foo', 1, expiry)
+            cache_class.find_by_key('foo').expiry.should ==
+              Time.now.to_i + expiry
+          end
+        end
+
+        it 'should support an unix time expiry' do
+          [
+            MemCache::ActiveRecord::THIRTY_DAYS + 1,
+            Time.now.to_i,
+          ].each do |expiry|
+            dbcache.set('foo', 1, expiry)
+            cache_class.find_by_key('foo').expiry.should == expiry
+          end
+        end
+
         unless ENV['LOG']
           it 'should behave like MemCache with over 64KB value' do
             value = 'a' * (2 ** 16 + 1)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: memcache-client-activerecord
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - ISHIHARA Masaki
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-30 00:00:00 +09:00
+date: 2009-12-31 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -90,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: mc-activerecord
 rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3