module ActiveSupport::Cache::Strategy::LocalCache

def bypass_local_cache 

def bypass_local_cache
  save_cache = Thread.current[thread_local_key]
  begin
    Thread.current[thread_local_key] = nil
    yield
  ensure
    Thread.current[thread_local_key] = save_cache
  end
end

def cleanup(options = nil) # :nodoc:

:nodoc: 
def cleanup(options = nil) # :nodoc:
  local_cache.clear(options) if local_cache
  super
end

def clear(options = nil) # :nodoc:

:nodoc: 
def clear(options = nil) # :nodoc:
  local_cache.clear(options) if local_cache
  super
end

def decrement(name, amount = 1, options = nil) # :nodoc:

:nodoc: 
def decrement(name, amount = 1, options = nil) # :nodoc:
  value = bypass_local_cache{super}
  if local_cache
    local_cache.mute do
      if value
        local_cache.write(name, value, options)
      else
        local_cache.delete(name, options)
      end
    end
  end
  value
end

def delete_entry(key, options) # :nodoc:

:nodoc: 
def delete_entry(key, options) # :nodoc:
  local_cache.delete_entry(key, options) if local_cache
  super
end

def increment(name, amount = 1, options = nil) # :nodoc:

:nodoc: 
def increment(name, amount = 1, options = nil) # :nodoc:
  value = bypass_local_cache{super}
  if local_cache
    local_cache.mute do
      if value
        local_cache.write(name, value, options)
      else
        local_cache.delete(name, options)
      end
    end
  end
  value
end

def local_cache 

def local_cache
  Thread.current[thread_local_key]
end

def middleware

duration of request.
Middleware class can be inserted as a Rack handler to be local cache for the 
def middleware
  @middleware ||= Middleware.new(
    "ActiveSupport::Cache::Strategy::LocalCache",
    thread_local_key)
end

def read_entry(key, options) # :nodoc:

:nodoc: 
def read_entry(key, options) # :nodoc:
  if local_cache
    entry = local_cache.read_entry(key, options)
    unless entry
      entry = super
      local_cache.write_entry(key, entry, options)
    end
    entry
  else
    super
  end
end

def thread_local_key 

def thread_local_key
  @thread_local_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, '_').to_sym
end

def with_local_cache

Use a local cache for the duration of block. 
def with_local_cache
  save_val = Thread.current[thread_local_key]
  begin
    Thread.current[thread_local_key] = LocalStore.new
    yield
  ensure
    Thread.current[thread_local_key] = save_val
  end
end

def write_entry(key, entry, options) # :nodoc:

:nodoc: 
def write_entry(key, entry, options) # :nodoc:
  local_cache.write_entry(key, entry, options) if local_cache
  super
end