ngmoco-cache-money 0.2.10 → 0.2.13

data/db/schema.rb

@@ -9,4 +9,10 @@ ActiveRecord::Schema.define(:version => 2) do
     t.integer "story_id"
     t.string "name"
   end
+  
+  create_table :sessions, :force => true do |t|
+    t.string :session_id
+    t.text   :data
+    t.timestamps
+  end
 end

data/lib/cache_money.rb

@@ -1,8 +1,5 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-
-require 'rubygems'
-require 'activesupport'
-require 'activerecord'
+require 'active_support'
+require 'active_record'
 
 require 'cash/lock'
 require 'cash/transactional'
@@ -27,9 +24,21 @@ require 'cash/util/marshal'
 
 class ActiveRecord::Base
   def self.is_cached(options = {})
-    options.assert_valid_keys(:ttl, :repository, :version)
-    include Cash unless ancestors.include?(Cash)
-    Cash::Config.create(self, options)
+    if options == false
+      include NoCash
+    else
+      options.assert_valid_keys(:ttl, :repository, :version)
+      include Cash unless ancestors.include?(Cash)
+      Cash::Config.create(self, options)
+    end
+  end
+
+  def <=>(other)
+    if self.id == other.id then 
+      0
+    else
+      self.id < other.id ? -1 : 1
+    end
   end
 end
 
@@ -49,7 +58,27 @@ module Cash
     end
 
     def transaction_with_cache_transaction(&block)
-      repository.transaction { transaction_without_cache_transaction(&block) }
+      if cache_config
+        repository.transaction { transaction_without_cache_transaction(&block) }
+      else
+        transaction_without_cache_transaction(&block)
+      end
+    end
+
+    def cacheable?(*args)
+      true
     end
   end
 end
+module NoCash
+  def self.included(active_record_class)
+    active_record_class.class_eval do
+      extend ClassMethods
+    end
+  end
+  module ClassMethods
+    def cachable?(*args)
+      false
+    end
+  end
+end

data/lib/cash/buffered.rb

@@ -80,15 +80,12 @@ module Cash
       end
     end
 
-    def method_missing(method, *args, &block)
-      @cache.send(method, *args, &block)
-    end
-
     def respond_to?(method)
       @cache.respond_to?(method)
     end
 
     protected
+
     def perform_commands
       @commands.each do |command|
         command.call(@cache)
@@ -98,6 +95,12 @@ module Cash
     def buffer_command(command)
       @commands << command
     end
+    
+    private
+    
+    def method_missing(method, *args, &block)
+      @cache.send(method, *args, &block)
+    end
   end
 
   class NestedBuffered < Buffered

data/lib/cash/config.rb

@@ -15,8 +15,11 @@ module Cash
     module ClassMethods
       def self.extended(a_class)
         class << a_class
-          attr_reader :cache_config
-          delegate :repository, :indices, :to => :@cache_config
+          def cache_config
+            @cache_config ? @cache_config : superclass.cache_config
+          end
+          
+          delegate :repository, :indices, :to => :cache_config
           alias_method_chain :inherited, :cache_config
         end
       end
@@ -52,7 +55,7 @@ module Cash
       end
 
       def ttl
-        @options[:ttl] || 0
+        @ttl ||= @options[:ttl] || repository.default_ttl || 1.day
       end
 
       def version

data/lib/cash/index.rb

@@ -7,6 +7,7 @@ module Cash
     DEFAULT_OPTIONS = { :ttl => 1.day }
 
     def initialize(config, active_record, attributes, options = {})
+      DEFAULT_OPTIONS[:ttl] = config.ttl || DEFAULT_OPTIONS[:ttl]
       @config, @active_record, @attributes, @options = config, active_record, Array(attributes).collect(&:to_s).sort, DEFAULT_OPTIONS.merge(options)
     end
 
@@ -87,7 +88,11 @@ module Cash
       new_attribute_value_pairs = []
       @attributes.each do |name|
         new_value = object.attributes[name]
-        original_value = object.send("#{name}_was")
+        if object.changed.include? name
+          original_value = object.send("#{name}_was")
+        else
+          original_value = new_value
+        end
         old_attribute_value_pairs << [name, original_value]
         new_attribute_value_pairs << [name, new_value]
       end

data/lib/cash/local.rb

@@ -12,12 +12,6 @@ module Cash
     ensure
       @remote_cache = original_cache
     end
-
-    def method_missing(method, *args, &block)
-      autoload_missing_constants do
-        @remote_cache.send(method, *args, &block)
-      end
-    end
     
     def autoload_missing_constants
       yield if block_given?
@@ -29,6 +23,14 @@ module Cash
         raise error
       end
     end
+
+    private
+    
+    def method_missing(method, *args, &block)
+      autoload_missing_constants do
+        @remote_cache.send(method, *args, &block)
+      end
+    end
   end
 
   class LocalBuffer
@@ -65,6 +67,8 @@ module Cash
       @local_cache.delete(key)
     end
 
+    private
+    
     def method_missing(method, *args, &block)
       @remote_cache.send(method, *args, &block)
     end

data/lib/cash/lock.rb

@@ -1,3 +1,5 @@
+require 'socket'
+
 module Cash
   class Lock
     class Error < RuntimeError; end
@@ -25,12 +27,13 @@ module Cash
 
     def acquire_lock(key, lock_expiry = DEFAULT_EXPIRY, retries = DEFAULT_RETRY, initial_wait = INITIAL_WAIT)
       retries.times do |count|
-        response = @cache.add("lock/#{key}", Process.pid, lock_expiry)
+        response = @cache.add("lock/#{key}", host_pid, lock_expiry)
         return if response == "STORED\r\n"
+        return if recursive_lock?(key)
         exponential_sleep(count, initial_wait) unless count == retries - 1
       end
       debug_lock(key)
-      raise Error, "Couldn't acquire memcache lock for: #{key}   server: #{@cache.get_server_for_key(key)}"
+      raise Error, "Couldn't acquire memcache lock on #{@cache.get_server_for_key("lock/#{key}")}"
     end
 
     def release_lock(key)
@@ -44,13 +47,17 @@ module Cash
     private
 
     def recursive_lock?(key)
-      @cache.get("lock/#{key}") == Process.pid
+      @cache.get("lock/#{key}") == host_pid
     end
 
     def debug_lock(key)
-      @cache.logger.warn("#{@cache.get("lock/#{key}")}") if @cache.respond_to?(:logger) && @cache.logger.respond_to?(:warn)
+      @cache.logger.warn("Cash::Lock[#{key}]: #{@cache.get("lock/#{key}")}") if @cache.respond_to?(:logger) && @cache.logger.respond_to?(:warn)
     rescue
       @cache.logger.warn("#{$!}") if @cache.respond_to?(:logger) && @cache.logger.respond_to?(:warn)
     end
+    
+    def host_pid
+      "#{Socket.gethostname} #{Process.pid}"
+    end
   end
 end

data/lib/cash/mock.rb

@@ -0,0 +1,154 @@
+module Cash
+  class Mock < HashWithIndifferentAccess
+    attr_accessor :servers
+
+    class CacheEntry
+      attr_reader :value
+      
+      def self.default_ttl
+        1_000_000
+      end
+
+      def self.now
+        Time.now
+      end
+      
+      def initialize(value, raw, ttl)
+        if raw
+          @value = value.to_s
+        else
+          @value = Marshal.dump(value)
+        end
+        
+        if ttl.zero?
+          @ttl = self.class.default_ttl
+        else
+          @ttl = ttl
+        end
+        
+        @expires_at = self.class.now + @ttl
+      end
+      
+      
+      def expired?
+        self.class.now > @expires_at
+      end
+      
+      def increment(amount = 1)
+        @value = (@value.to_i + amount).to_s
+      end
+      
+      def decrement(amount = 1)
+        @value = (@value.to_i - amount).to_s
+      end
+      
+      def unmarshal
+        Marshal.load(@value)
+      end
+      
+      def to_i
+        @value.to_i
+      end
+    end
+    
+    attr_accessor :logging
+    
+    def initialize
+      @logging = false
+    end
+    
+    def get_multi(keys)
+      slice(*keys).collect { |k,v| [k, v.unmarshal] }.to_hash_without_nils
+    end
+
+    def set(key, value, ttl = CacheEntry.default_ttl, raw = false)
+      log "< set #{key} #{ttl}"
+      self[key] = CacheEntry.new(value, raw, ttl)
+      log('> STORED')
+    end
+
+    def get(key, raw = false)
+      log "< get #{key}"
+      unless self.has_unexpired_key?(key)
+        log('> END')
+        return nil
+      end
+      
+      log("> sending key #{key}")
+      log('> END')
+      if raw
+        self[key].value
+      else
+        self[key].unmarshal
+      end
+    end
+    
+    def delete(key, options = {})
+      log "< delete #{key}"
+      if self.has_unexpired_key?(key)
+        log "> DELETED"
+        super(key)
+      else
+        log "> NOT FOUND"
+      end
+    end
+
+    def incr(key, amount = 1)
+      if self.has_unexpired_key?(key)
+        self[key].increment(amount)
+        self[key].to_i
+      end
+    end
+
+    def decr(key, amount = 1)
+      if self.has_unexpired_key?(key)
+        self[key].decrement(amount)
+        self[key].to_i
+      end
+    end
+
+    def add(key, value, ttl = CacheEntry.default_ttl, raw = false)
+      if self.has_unexpired_key?(key)
+        "NOT_STORED\r\n"
+      else
+        set(key, value, ttl, raw)
+        "STORED\r\n"
+      end
+    end
+
+    def append(key, value)
+      set(key, get(key, true).to_s + value.to_s, nil, true)
+    end
+
+    def namespace
+      nil
+    end
+
+    def flush_all
+      log('< flush_all')
+      clear
+    end
+
+    def stats
+      {}
+    end
+
+    def reset_runtime
+      [0, Hash.new(0)]
+    end
+
+    def has_unexpired_key?(key)
+      self.has_key?(key) && !self[key].expired?
+    end
+    
+    def log(message)
+      return unless logging
+      logger.debug(message)
+    end
+    
+    def logger
+      @logger ||= ActiveSupport::BufferedLogger.new(Rails.root.join('log/cash_mock.log'))
+    end
+    
+  end
+end

data/lib/cash/query/abstract.rb

@@ -27,7 +27,7 @@ module Cash
           misses, missed_keys, objects = hit_or_miss(cache_keys, index, get_options)
           format_results(cache_keys, choose_deserialized_objects_if_possible(missed_keys, cache_keys, misses, objects))
         else
-          logger.debug("---- UNCACHEABLE #{table_name} - #{find_options.inspect} - #{get_options.inspect} - #{@options1.inspect} - #{@options2.inspect}") if logger
+          logger.debug("  \e[1;4;31mUNCACHEABLE\e[0m #{table_name} - #{find_options.inspect} - #{get_options.inspect} - #{@options1.inspect} - #{@options2.inspect}") if logger
           uncacheable
         end
       end
@@ -61,6 +61,7 @@ module Cash
 
       private
       def cacheable?(*optionss)
+        return false if @active_record.respond_to?(:cachable?) && ! @active_record.cachable?(*optionss)
         optionss.each { |options| return unless safe_options_for_cache?(options) }
         partial_indices = optionss.collect { |options| attribute_value_pairs_for_conditions(options[:conditions]) }
         return if partial_indices.include?(nil)
@@ -122,11 +123,15 @@ module Cash
             # value = sql_value == '?' ? values.shift : columns_hash[column_name].type_cast(sql_value)
             if sql_value == '?'
               value = values.shift
-            elsif sql_value[0..0] == ':' && values && values.count > 0 && values[0].is_a?(Hash)
-              symb  = sql_value[1..-1].to_sym
-              value = columns_hash[column_name].type_cast(values[0][symb])
             else
-              value = columns_hash[column_name].type_cast(sql_value)
+              column = columns_hash[column_name]
+              raise "could not find column #{column_name} in columns #{columns_hash.keys.join(',')}" if column.nil?
+              if sql_value[0..0] == ':' && values && values.count > 0 && values[0].is_a?(Hash)
+                symb  = sql_value[1..-1].to_sym
+                value = column.type_cast(values[0][symb])
+              else
+                value = column.type_cast(sql_value)
+              end
             end
             indices << [column_name, value]
           else
@@ -182,7 +187,10 @@ module Cash
 
       def find_from_keys(*missing_keys)
         missing_ids = Array(missing_keys).flatten.collect { |key| key.split('/')[2].to_i }
-        find_from_ids_without_cache(missing_ids, @options1)
+        options = @options1.dup
+        options.delete(:conditions)
+        options.delete(:limit)
+        find_from_ids_without_cache(missing_ids, options)
       end
     end
   end

data/lib/cash/query/primary_key.rb

@@ -26,7 +26,6 @@ module Cash
         @ids.collect { |id| "id/#{id}" }
       end
 
-
       def miss(missing_keys, options)
         find_from_keys(*missing_keys)
       end

data/lib/cash/transactional.rb

@@ -22,15 +22,16 @@ module Cash
       end
     end
 
-    def method_missing(method, *args, &block)
-      @cache.send(method, *args, &block)
-    end
-
     def respond_to?(method)
       @cache.respond_to?(method)
     end
 
     private
+
+    def method_missing(method, *args, &block)
+      @cache.send(method, *args, &block)
+    end
+
     def begin_transaction
       @cache = Buffered.push(@cache, @lock)
     end