retriever 0.1.0

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+.DS_Store
+dump.rdb
+coverage
+doc

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in retriever.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2011 Nelvin Driz <ndriz@exist.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,40 @@
+= Retriever
+
+A block result caching library.
+
+== Installation
+
+Either include to your <tt>Gemfile</tt> or install it.
+
+   # Bash
+   $ gem install retriever
+
+   # Gemfile
+   gem 'retriever'
+
+== Rails Usage
+
+Create file <tt>config/initializer/retriever.rb</tt> with your configuration.
+
+=== Example <tt>retriever.rb</tt>
+
+   Retriever.config.storage(:memory)
+   Retreiver.catch! do
+     target :bone do |parameters|
+       ...
+     end
+   end
+
+=== Example Usage (Controller)
+
+   def index
+     @bone = Retriever.fetch(:bone)
+   end
+
+== {Documentation}[http://rubydoc.info/gems/retriever/frames]
+
+== License
+
+Copyright (c) 2011 Nelvin Driz.
+
+Retriever is free software released under the MIT license.

data/Rakefile

@@ -0,0 +1,20 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+gem 'rdoc'
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "Retriever #{Retriever::VERSION}"
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.options << '--charset' << 'utf-8'
+  rdoc.options << '--line-numbers'
+  rdoc.main = 'README.rdoc'
+end
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "./spec/**/*_spec.rb"
+  t.rspec_opts = ['--color']
+end

data/lib/retriever/config.rb

@@ -0,0 +1,74 @@
+module Retriever
+# Configuration Namespace
+module Config
+class << self
+  # Boolean value to indicate whether or not key used for cache is encrypted or not.
+  attr_reader :encrypt
+
+  # Set encryption to boolean specified
+  #
+  # ==== Examples
+  #
+  #   Retriever.config.encrypt = true
+  #   Retriever.config.encrypt = false
+  #
+  def encrypt=(boolean)
+    require 'digest/sha1' if boolean
+    @encrypt = boolean
+  end
+
+  # Set storage handler to be used by retriever.
+  # This is a requirement to be set so that you
+  # can use retriever.
+  #
+  # ==== Storage Handlers (Built-in)
+  #
+  # * <tt>:ephemeral</tt> - Uses a ruby hash to store cache.
+  # * <tt>:redis</tt> - Use redis. (Requires <tt>redis</tt> gem.)
+  #
+  # ==== Custom Storage Handlers
+  # You can supply your own storage handler. In the class you supply,
+  # you need to specify the following methods:
+  #
+  # * <tt>set(key, value)</tt> - Used to set value in the cache store.
+  # * <tt>get(key)</tt> - Used to retrieve value from cache store.
+  # * <tt>delete(key)</tt> - Used to delete a record from cache store.
+  #
+  # ==== Examples
+  #
+  #   Retriever.config.storage(:ephemeral) # Set storage to memory.
+  #   Retriever.config.storage(:redis)  # Set storage to redis.
+  #
+  #   class CustomStorageHandler
+  #     def set(key, value)
+  #       ...
+  #     end
+  #
+  #     def get(key)
+  #       ...
+  #     end
+  #
+  #     def delete(key)
+  #       ...
+  #     end
+  #   end
+  #
+  #   Retriever.config.storage(CustomStorageHandler) # Set storage to a custom storage.
+  #
+  def storage(type)
+    if type.is_a? Class
+      ::Retriever.storage = type.new if type.is_a?(Class)
+    else
+      case type
+      when :ephemeral
+        require File.join(File.dirname(__FILE__), 'storage', 'ephemeral')
+        ::Retriever.storage = Retriever::Storage::Ephemeral.new
+      when :redis
+        require File.join(File.dirname(__FILE__), 'storage', 'redis')
+        ::Retriever.storage = Retriever::Storage::Redis.new
+      end
+    end
+  end
+end
+end
+end

data/lib/retriever/instruction.rb

@@ -0,0 +1,63 @@
+module Retriever
+# Instruction is used by retriever as an object that would
+# store set attributes and options while specifying your
+# targets in <tt>Retriever.catch!</tt>
+#
+class Instruction
+  # Key used by instruction for storage manipulation.
+  attr_accessor :key
+
+  # Block executed to retrieve value to be cached.
+  attr_accessor :block
+
+  # Instantiate Instruction
+  #
+  # ==== Parameters
+  #
+  # * <tt>:key</tt> - Key used to store and retrieve value from cache.
+  # * <tt>:options</tt> - Options defined in <tt>Retriever.catch!</tt>
+  # * <tt>:block</tt> - Block is the <tt>Proc</tt> object to be executed.
+  #   Resulting value would be the cached.
+  #
+  def initialize(key, options, block)
+    @key   = key
+    @block = block
+    @validity = options[:validity] || 365.days
+  end
+
+  # Checks if value in storage is expired before trying to retrieve
+  # a new value. Value in storage is returned if value is still valid.
+  #
+  # ==== Parameters
+  #
+  # * <tt>:storage</tt> - Instance of the storage handler.
+  # * <tt>:block_parameters</tt> - Arguments sent to the block if value
+  #   in storage is expired.
+  #
+  def execute(storage, block_parameters)
+    if expired? then execute!(storage, block_parameters) else storage.get(key) end
+  end
+
+  # Cache the result of the block. Just like <tt>execute</tt> but does not
+  # check cached value.
+  #
+  # ==== Parameters
+  #
+  # * <tt>:storage</tt> - Instance of the storage handler.
+  # * <tt>:block_parameters</tt> - Arguments sent to the block if value
+  #   in storage is expired.
+  #
+  def execute!(storage, block_parameters)
+    @last_execution = Time.now
+    storage.set(key, block.call(*block_parameters))
+  end
+
+private
+  # Check if cached value is expired
+  #
+  def expired?
+    return true unless @last_execution
+    Time.now - @last_execution > @validity
+  end
+end
+end

data/lib/retriever/storage/ephemeral.rb

@@ -0,0 +1,32 @@
+# Storage handler namespace
+module Retriever::Storage
+# Storage handler for a Hash Backend
+class Ephemeral
+  # Instance of Hash
+  attr_reader :storage
+
+  # Instantiate hash object as storage of cache.
+  #
+  def initialize
+    @storage = Hash.new
+  end
+
+  # Set record in hash.
+  #
+  def set(key, value)
+    storage[key] = value
+  end
+
+  # Get record from hash.
+  #
+  def get(key)
+    storage[key]
+  end
+
+  # Delete record in hash.
+  #
+  def delete(key)
+    storage.delete(key)
+  end
+end
+end

data/lib/retriever/storage/redis.rb

@@ -0,0 +1,51 @@
+require 'redis'
+require 'json'
+
+module Retriever::Storage
+# Storage handler for a Redis Backend
+class Redis
+  # Instance of Redis
+  attr_reader :storage
+
+  # Instantiate Redis Connection (Default Settings Used)
+  #
+  def initialize
+    @storage = ::Redis.new
+  end
+
+  # Set record in storage.
+  # Serializes value to JSON if applicable.
+  #
+  def set(key, value)
+    value = serialize(value)
+    storage.set(key, value)
+    JSON.parse(value) rescue value
+  end
+
+  # Get record from storage.
+  # Deserialize value from JSON if applicable.
+  #
+  def get(key)
+    value = storage.get(key)
+    JSON.parse(value) rescue value
+  end
+
+  # Delete record from storage.
+  #
+  def delete(key)
+    storage.del key
+  end
+
+private
+  # Serialize value by converting it to JSON if possible.
+  #
+  def serialize(value)
+    case value.class.to_s
+    when 'String' then value
+    else
+      value.to_json rescue value.to_s
+    end
+  end
+
+end
+end

data/lib/retriever/version.rb

@@ -0,0 +1,4 @@
+module Retriever
+  # Version of Retriever
+  VERSION = "0.1.0"
+end

data/lib/retriever.rb

@@ -0,0 +1,149 @@
+require File.join('retriever', 'version')
+require File.join('retriever', 'config')
+require File.join('retriever', 'instruction')
+
+# Main Retriever Entry Point
+module Retriever
+class << self
+  # Instance of storage handler.
+  attr_accessor :storage
+
+  # Array of instructions.
+  attr_accessor :instructions
+
+  # Setup targets for retriever to cache.
+  #
+  # ==== Example
+  #
+  #   Retriever.catch! do
+  #     target :bone do
+  #       'wishbone'
+  #     end
+  #   end
+  #
+  def catch!(&block)
+    @instance_timestamp = Time.now
+    @instructions       = Hash.new
+    self.instance_eval &block
+  end
+
+  # Setup a new <tt>target</tt> for retriever to catch.
+  #
+  # ==== Parameters
+  #
+  # * <tt>:name</tt> - Identifier used to call the block whenever you call
+  #   <tt>fetch</tt> or <tt>fetch!</tt>.
+  # * <tt>:options</tt> - Options that modify basic instruction of simply
+  #   caching the result of the block.
+  # * <tt>:block</tt> - The block to be executed with it's result being cached.
+  #
+  # ==== Options
+  #
+  # * <tt>:validity</tt> - Sets length of validity of a certain cache.
+  #   After the cache expires, retriever simply executes the block again.
+  #
+  #     target :bone, :validity => 10.minutes
+  #
+  # ==== Example
+  #
+  #   Retriever.catch! do
+  #     @counter = 0
+  #     target :bone, :validity => 10.minutes do
+  #       @counter += 1
+  #     end
+  #   end
+  #
+  #   Retriever.fetch(:bone) # => 1
+  #   # After 10 minutes
+  #   Retreiver.fetch(:bone) # => 2
+  #
+  def target(name, options = {}, &block)
+    key = keyify(name)
+    instructions[key] = Instruction.new(key, options, block)
+  end
+
+  # Fetch data based upon the execution result of the corresponding
+  # instruction identified by the <tt>target_name</tt>. If data cached
+  # is still valid, that data would be returned.
+  #
+  # ==== Parameters
+  #
+  # * <tt>:target_name</tt> - The name used to identify the instruction.
+  # * <tt>:*block_parameters</tt> - Parameters passed on to the block
+  #   that is part of the instruction.
+  #
+  # ==== Examples
+  #
+  #   Retriever.fetch(:bone)
+  #
+  def fetch(target_name, *block_parameters)
+    key = keyify(target_name)
+    instruction = instructions[key]
+    instruction.execute(storage, block_parameters)
+  end
+
+  # Fetch data based upon the execution result of the corresponding
+  # instruction identified by the <tt>target_name</tt>.
+  #
+  # ==== Parameters
+  #
+  # * <tt>:target_name</tt> - The name used to identify the instruction.
+  # * <tt>:*block_parameters</tt> - Parameters passed on to the block
+  #   that is part of the instruction.
+  #
+  # ==== Examples
+  #
+  #   Retriever.fetch(:bone)
+  #
+  def fetch!(target_name, *block_parameters)
+    key = keyify(target_name)
+    instruction = instructions[key]
+    instruction.execute!(storage, block_parameters)
+  end
+
+  # Check if keys used for the cache store is encrypted or not encrypted.
+  # Basis of key is namespaced to retriever as well as timestamped.
+  # (Timestamp comes from the instance start.)
+  #
+  def encrypted?
+    config.encrypt || false
+  end
+
+  # Returns config namespace.
+  #
+  def config
+    Config
+  end
+
+  # Delete all cache. Automatically run on instance process termination.
+  #
+  def clean!
+    return unless instructions
+    instructions.keys.each do |key|
+      storage.delete(key)
+    end
+  end
+
+private
+  # Namespaces <tt>target_name</tt> to retriever as well as timestamped
+  # with the instance start timestamp. This key is also encrypted using
+  # SHA1 if set to be encrypted.
+  #
+  # ==== Examples
+  #
+  #   To set encryption:
+  #   Retriever.config.encrypt = true  # Set encryption to true
+  #   Retriever.config.encrypt = false # Set encryption to false
+  #
+  def keyify(target_name)
+    key = "Retriever::#{target_name}::#{@instance_timestamp}"
+    key = Digest::SHA1.hexdigest(key) if encrypted?
+    return key
+  end
+
+end
+end
+
+at_exit do
+  Retriever.clean!
+end

data/retriever.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "retriever/version"
+
+Gem::Specification.new do |s|
+  s.name        = 'retriever'
+  s.version     = Retriever::VERSION
+  s.authors     = ['Nelvin Driz']
+  s.email       = ['ndriz@exist.com']
+  s.homepage    = "http://github.com/Keoven/Retriever"
+  s.summary     = %q{Retriever is a block result caching library.}
+  s.description = %q{
+    Retriever allows caching of the result of a block. It currently supports ruby memory storage and redis.
+  }
+
+  s.rubyforge_project = 'retriever'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # Development
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'redis'
+  s.add_development_dependency 'yajl-ruby'
+  s.add_development_dependency 'rails'
+  s.add_development_dependency 'timecop'
+  s.add_development_dependency 'ruby-debug19'
+  s.add_development_dependency 'simplecov'
+
+  # Runtime
+  s.add_runtime_dependency 'activesupport'
+end

data/spec/lib/custom_storage_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+class Custom
+  attr_reader :storage
+
+  def initialize
+    @storage = Hash.new
+  end
+
+  def set(key, value)
+    storage[key] = value
+  end
+
+  def get(key)
+    storage[key]
+  end
+
+  def delete(key)
+    storage.delete(key)
+  end
+end
+
+describe Retriever do
+  before do
+    Retriever.config.storage(Custom)
+  end
+
+  it 'should fetch ball' do
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+
+  it 'should memoize ball' do
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.storage.should_receive(:set).once.and_return('ball')
+    Retriever.fetch(:ball).should be_eql('ball')
+    Retriever.storage.stub!(:get).and_return('ball')
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+
+  it 'should only be valid in 10 minutes' do
+    now = Time.now
+    Timecop.freeze(now)
+    Retriever.catch! do
+      @counter = 0
+      target :ball, :validity => 10.minutes do
+        @counter += 1
+      end
+    end
+    Retriever.fetch(:ball).should be_eql(1)
+    Timecop.freeze(now + 5.minutes)
+    Retriever.fetch(:ball).should be_eql(1)
+    Timecop.freeze(now + 10.minutes)
+    Retriever.fetch(:ball).should be_eql(1)
+    Timecop.freeze(now + 10.minutes + 1.second)
+    Retriever.fetch(:ball).should be_eql(2)
+    Timecop.freeze(now + 15.minutes)
+    Retriever.fetch(:ball).should be_eql(2)
+    Timecop.freeze(now)
+    Retriever.fetch(:ball).should be_eql(2)
+    Timecop.freeze(now + 30.minutes)
+    Retriever.fetch(:ball).should be_eql(3)
+  end
+
+  it 'should be able to pass parameters' do
+    Retriever.catch! do
+      target :ball do |arg1, arg2|
+        arg1 + arg2
+      end
+    end
+
+    Retriever.fetch(:ball, 1, 2).should be_eql(3)
+  end
+
+  it 'should be able to fetch forcefully' do
+    now = Time.now
+    Timecop.freeze(now)
+    Retriever.catch! do
+      @counter = 0
+      target :ball, :validity => 10.minutes do
+        @counter += 1
+      end
+    end
+    Retriever.fetch(:ball).should be_eql(1)
+    Retriever.fetch!(:ball).should be_eql(2)
+    Retriever.fetch(:ball).should be_eql(2)
+  end
+
+  it 'should be encrypted' do
+    Retriever.config.encrypt = true
+    Retriever.should be_encrypted
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+end

data/spec/lib/default_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Retriever do
+  before do
+    Retriever.config.storage(:ephemeral)
+  end
+
+  it 'should fetch ball' do
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+
+  it 'should memoize ball' do
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.storage.should_receive(:set).once.and_return('ball')
+    Retriever.fetch(:ball).should be_eql('ball')
+    Retriever.storage.stub!(:get).and_return('ball')
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+
+  it 'should only be valid in 10 minutes' do
+    now = Time.now
+    Timecop.freeze(now)
+    Retriever.catch! do
+      @counter = 0
+      target :ball, :validity => 10.minutes do
+        @counter += 1
+      end
+    end
+    Retriever.fetch(:ball).should be_eql(1)
+    Timecop.freeze(now + 5.minutes)
+    Retriever.fetch(:ball).should be_eql(1)
+    Timecop.freeze(now + 10.minutes)
+    Retriever.fetch(:ball).should be_eql(1)
+    Timecop.freeze(now + 10.minutes + 1.second)
+    Retriever.fetch(:ball).should be_eql(2)
+    Timecop.freeze(now + 15.minutes)
+    Retriever.fetch(:ball).should be_eql(2)
+    Timecop.freeze(now)
+    Retriever.fetch(:ball).should be_eql(2)
+    Timecop.freeze(now + 30.minutes)
+    Retriever.fetch(:ball).should be_eql(3)
+  end
+
+  it 'should be able to pass parameters' do
+    Retriever.catch! do
+      target :ball do |arg1, arg2|
+        arg1 + arg2
+      end
+    end
+
+    Retriever.fetch(:ball, 1, 2).should be_eql(3)
+  end
+
+  it 'should be able to fetch forcefully' do
+    now = Time.now
+    Timecop.freeze(now)
+    Retriever.catch! do
+      @counter = 0
+      target :ball, :validity => 10.minutes do
+        @counter += 1
+      end
+    end
+    Retriever.fetch(:ball).should be_eql(1)
+    Retriever.fetch!(:ball).should be_eql(2)
+    Retriever.fetch(:ball).should be_eql(2)
+  end
+
+  it 'should be encrypted' do
+    Retriever.config.encrypt = true
+    Retriever.should be_encrypted
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+end

data/spec/lib/redis_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+
+describe Retriever do
+  before do
+    Retriever.config.storage(:redis)
+  end
+
+  it 'should fetch ball' do
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+
+  it 'should memoize ball' do
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.storage.should_receive(:set).once.and_return('ball')
+    Retriever.fetch(:ball).should be_eql('ball')
+    Retriever.storage.stub!(:get).and_return('ball')
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+
+  it 'should only be valid in 10 minutes' do
+    now = Time.now
+    Timecop.freeze(now)
+    Retriever.catch! do
+      @counter = 0
+      target :ball, :validity => 10.minutes do
+        @counter += 1
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('1')
+    Timecop.freeze(now + 5.minutes)
+    Retriever.fetch(:ball).should be_eql('1')
+    Timecop.freeze(now + 10.minutes)
+    Retriever.fetch(:ball).should be_eql('1')
+    Timecop.freeze(now + 10.minutes + 1.second)
+    Retriever.fetch(:ball).should be_eql('2')
+    Timecop.freeze(now + 15.minutes)
+    Retriever.fetch(:ball).should be_eql('2')
+    Timecop.freeze(now)
+    Retriever.fetch(:ball).should be_eql('2')
+    Timecop.freeze(now + 30.minutes)
+    Retriever.fetch(:ball).should be_eql('3')
+  end
+
+  it 'should be able to pass parameters' do
+    Retriever.catch! do
+      target :ball do |arg1, arg2|
+        arg1 + arg2
+      end
+    end
+
+    Retriever.fetch(:ball, 1, 2).should be_eql('3')
+  end
+
+  it 'should be able to fetch forcefully' do
+    now = Time.now
+    Timecop.freeze(now)
+    Retriever.catch! do
+      @counter = 0
+      target :ball, :validity => 10.minutes do
+        @counter += 1
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('1')
+    Retriever.fetch!(:ball).should be_eql('2')
+    Retriever.fetch(:ball).should be_eql('2')
+  end
+
+  it 'should be encrypted' do
+    Retriever.config.encrypt = true
+    Retriever.should be_encrypted
+    Retriever.catch! do
+      target :ball do
+        'ball'
+      end
+    end
+    Retriever.fetch(:ball).should be_eql('ball')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec/'
+end
+
+require File.join(
+  File.dirname(__FILE__),
+  '..', 'lib', 'retriever')
+require 'timecop'
+require 'active_support'
+require 'active_support/time'
+
+RSpec.configure do |config|
+  [:all, :each].each do |x|
+    config.after(x) do
+      Retriever.clean!
+    end
+  end
+end

metadata

@@ -0,0 +1,154 @@
+--- !ruby/object:Gem::Specification
+name: retriever
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Nelvin Driz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70342454584380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342454584380
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: &70342454583340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342454583340
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70342454582340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342454582340
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70342454580180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342454580180
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70342454579060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342454579060
+- !ruby/object:Gem::Dependency
+  name: ruby-debug19
+  requirement: &70342454578320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342454578320
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &70342454577260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70342454577260
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70342454576500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70342454576500
+description: ! "\n    Retriever allows caching of the result of a block. It currently
+  supports ruby memory storage and redis.\n  "
+email:
+- ndriz@exist.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/retriever.rb
+- lib/retriever/config.rb
+- lib/retriever/instruction.rb
+- lib/retriever/storage/ephemeral.rb
+- lib/retriever/storage/redis.rb
+- lib/retriever/version.rb
+- retriever.gemspec
+- spec/lib/custom_storage_spec.rb
+- spec/lib/default_spec.rb
+- spec/lib/redis_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/Keoven/Retriever
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: retriever
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Retriever is a block result caching library.
+test_files:
+- spec/lib/custom_storage_spec.rb
+- spec/lib/default_spec.rb
+- spec/lib/redis_spec.rb
+- spec/spec_helper.rb