persistent-cache-ram 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7d3cdc58f9ac1e510011927748260e063825f52
+  data.tar.gz: 63c5741f23250ac692f5f0b7e92d2e13f64bc5bb
+SHA512:
+  metadata.gz: 6c993c25d4af5093b66223a3ea1b74cce639af34d41c5973445350ff58eccdb62b356aa0d3e5e754558d9adf7687faa69cf917fdaadb025ea7cb1c593d553acb
+  data.tar.gz: a5b627e4efff38f5f8f08dc5ed4502bbd664da66640cb8ccef9a5dff07f108e4a2936896748ff13ffb90e7fd8d74e0c0bc9a24a4b8397c1456c4ff3917e1101a

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+coverage

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+gem 'rspec'
+
+# Specify your gem's dependencies in persistent-cache.gemspec
+gemspec
+

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Wynand van Dyk, Ernst van Graan, Hetzner (Pty) Ltd
+
+MIT License
+
+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.md

@@ -0,0 +1,33 @@
+# Persistent::Cache
+
+Persistent cache behaves like a hash, with a pluggable back-end. This gem only implements STORAGE_RAM, and in doing so has no dependencies such as sqlite, etc. Please see the persistent-cache gem for support for more back-ends and a comprehensive README.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'persistent-cache-ram'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install persistent-cache
+
+## Usage
+
+    Please see the persistent-cache gem for usage instructions. This is a STORAGE_RAM only implementation.
+
+## Contributing
+
+Please send feedback and comments to the authors at:
+
+Ernst van Graan <ernst.van.graan@hetzner.co.za>
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lib/persistent-cache.rb

@@ -0,0 +1,122 @@
+require "persistent-cache/version"
+require "persistent-cache/storage/storage_ram"
+
+module Persistent
+  class Cache
+    STORAGE_RAM = 'ram' unless defined? STORAGE_RAM
+
+    # Fresh is 1 day less than the bacula default job retention time. If this is configured differently, FRESH should be updated as well.
+    FRESH = 15465600; FRESH.freeze
+
+    attr_accessor :storage_details
+    attr_accessor :storage
+    attr_accessor :fresh
+    attr_accessor :encoding
+
+    def initialize(storage_details, fresh = FRESH, storage = STORAGE_RAM)
+      raise ArgumentError.new("No storage details provided") if storage_details.nil? or storage_details == ""
+
+      @storage = StorageRAM.new if storage == STORAGE_RAM
+      @fresh = fresh
+      @storage_details = storage_details
+
+      raise ArgumentError.new("Unsupported storage type #{storage}}") if @storage.nil?
+    end
+
+    def set(key, value, timestamp)
+      if value.nil?
+        delete_entry(key)
+      else
+        save_key_value_pair(key, value, timestamp)
+      end
+    end
+
+    def []=(key, value)
+      if value.nil?
+        delete_entry(key)
+      else
+        save_key_value_pair(key, value)
+      end
+    end
+
+    def [](key)
+      lookup_key(key)
+    end
+
+    def each(&block)
+      keys.each do |key|
+        yield key, lookup_key(key)
+      end
+    end
+
+    def size
+      @storage.size
+    end
+
+    def keys
+      @storage.keys    
+    end
+
+    def clear
+      @storage.clear
+    end
+
+    def timestamp?(key)
+      k = encode_if_requested(key)
+      result = @storage.lookup_key(k)
+      return nil if result.nil? or result[1].nil?
+      Time.parse(result[1])
+    end
+
+    def key?(key)
+      if @storage.keys and @storage.keys[0]
+        @storage.keys[0].each do |k|
+          return k if k == key
+        end
+      end
+      return nil      
+    end
+
+    private
+
+    def encode_if_requested(key)
+      return key.encode(@encoding) if (not @encoding.nil?) and (key.is_a?(String))
+      key
+    end
+
+    def save_key_value_pair(key, value, timestamp = nil)
+      k = encode_if_requested(key)
+      @storage.delete_entry(k)
+      @storage.save_key_value_pair(k, value, timestamp)
+    end
+
+    def lookup_key(key)
+      k = encode_if_requested(key)
+      result = @storage.lookup_key(k)
+      return nil if nil_result?(result)
+      return nil if stale_entry?(k, result)
+
+      return result[0]
+    end
+
+    def stale_entry?(key, result)
+      return false if @fresh.nil?
+
+      timestamp = Time.parse(result[1])
+      if ((Time.now - timestamp) > @fresh)
+        delete_entry(key)
+        return true
+      end
+      return false
+    end
+
+    def delete_entry(key)
+      k = encode_if_requested(key)
+      @storage.delete_entry(key)
+    end
+
+    def nil_result?(result)
+      result.nil? or result[0].nil?
+    end
+  end
+end

data/lib/persistent-cache/storage/storage_ram.rb

@@ -0,0 +1,51 @@
+require "eh/eh"
+
+module Persistent
+  class StorageRAM
+    attr_accessor :storage
+
+    def initialize()
+      @storage = {}
+    end
+
+    def save_key_value_pair(serialized_key, serialized_value, timestamp = nil)
+      delete_entry(serialized_key)
+      time_entry = timestamp.nil? ? Time.now.to_s : timestamp.to_s
+      EH::retry!(:args => [serialized_key, serialized_value, time_entry]) do
+        @storage[serialized_key] = {:value => serialized_value, :timestamp => time_entry}
+      end
+    end
+
+    def lookup_key(serialized_key)
+      EH::retry!(:args => [serialized_key]) do
+        return [] if @storage[serialized_key].nil?
+        [@storage[serialized_key][:value], @storage[serialized_key][:timestamp]]
+      end
+    end
+
+    def delete_entry(serialized_key)
+      EH::retry!(:args => [serialized_key]) do
+        @storage.delete(serialized_key)
+      end
+    end
+
+    def size
+      EH::retry!(:args => []) do
+        @storage.size
+      end
+    end
+
+    def keys
+      EH::retry!(:args => []) do
+        return [] if @storage.keys == []
+        [@storage.keys]
+      end
+    end
+
+    def clear
+      EH::retry!(:args => []) do
+        @storage.clear
+      end
+    end
+  end
+end

data/lib/persistent-cache/version.rb

@@ -0,0 +1,5 @@
+module Persistent
+  class Cache
+    VERSION = "0.4.1"
+  end
+end

data/persistent-cache-ram.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/persistent-cache/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ernst van Graan"]
+  gem.email         = ["ernst.van.graan@hetzner.co.za"]
+  gem.description   = %q{Persistent Cache limited to STORAGE_RAM}
+  gem.summary       = %q{Persistent Cache limited to STORAGE_RAM}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "persistent-cache-ram"
+  gem.require_paths = ["lib"]
+  gem.version       = Persistent::Cache::VERSION
+  gem.add_development_dependency 'rspec', '2.12.0'
+  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'simplecov-rcov'
+#  gem.add_development_dependency 'debugger'
+  gem.add_dependency 'eh'
+end

data/spec/persistent-cache_spec.rb

@@ -0,0 +1,214 @@
+require 'spec_helper'
+
+require "persistent-cache"
+
+describe Persistent::Cache do
+  before :each do
+    @db_name = get_database_name
+    @mock_storage = double(Persistent::StorageRAM)
+    @test_key = "testkey"
+    @test_value = "testvalue"
+    FileUtils.rm_f(@db_name)
+  end
+
+  context "when constructing" do
+    it "should receive database connection details and create a StorageRAM instance if specified" do
+      @pcache = Persistent::Cache.new(@db_name, Persistent::Cache::STORAGE_RAM)
+      expect(@pcache.class).to eq(Persistent::Cache)
+      expect(@pcache.storage.is_a?(Persistent::StorageRAM)).to eq(true)
+    end
+
+    it "should raise an ArgumentError if storage details have not been provided" do
+      expect {
+        Persistent::Cache.new(nil)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "should remember the freshness interval if provided" do
+      @pcache = Persistent::Cache.new(@db_name, 123)
+      expect(@pcache.fresh).to eq(123)
+    end
+
+    it "should remember the storage details provided" do
+      @pcache = Persistent::Cache.new(@db_name, 123)
+      expect(@pcache.storage_details).to eq(@db_name)
+    end
+
+    it "should default the freshness interval to FRESH if not provided" do
+      @pcache = Persistent::Cache.new(@db_name)
+      expect(@pcache.fresh).to eq(Persistent::Cache::FRESH)
+    end
+
+    it "should raise an ArgumentError if an unknown storage type has been provided" do
+      expect {
+        Persistent::Cache.new(@db_name, 100, "unknown")
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "When assigning a value to a key" do
+    it "should ask the storage handler to first delete, then save the key/value pair" do
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, nil)
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache[@test_key] = @test_value
+    end
+
+    it "should ask the storage handler to delete if the value is nil using []" do
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry).with(@test_key)
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache[@test_key] = nil
+    end
+
+    it "should ask the storage handler to delete if the value is nil using set()" do
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry).with(@test_key)
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache.set(@test_key, nil, Time.now)
+    end
+
+    it "should serialize the key and value for persistence" do
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, nil)
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache[@test_key] = @test_value
+    end
+
+    it "should ask the storage handler to store the value, with a specific timestamp if specified" do
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+      expect(@mock_storage).to receive(:delete_entry)
+      timestamp = Time.now - 100
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, timestamp)
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache.set(@test_key, @test_value, timestamp)
+    end
+  end
+  
+  context "When looking up a value given its key" do
+    it "should retrieve the value from storage using lookup_key and deserialize the value" do
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:save_key_value_pair).with(@test_key, @test_value, nil)
+      expect(@mock_storage).to receive(:lookup_key).with(@test_key).and_return([@test_value, Time.now.to_s])
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache[@test_key] = @test_value
+      result = @pcache[@test_key]
+      expect(result).to eq(@test_value)
+    end
+
+    it "should return nil if a value exists but it not fresh" do
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:lookup_key).with(@test_key).and_return([@test_value, (Time.now - Persistent::Cache::FRESH).to_s])
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+
+      @pcache = Persistent::Cache.new(@db_name)
+      expect(@pcache[@test_key].nil?).to eq(true)
+    end
+
+    it "should remove from the cache an entry it encounters that is not fresh" do
+      expect(@mock_storage).to receive(:delete_entry)
+      expect(@mock_storage).to receive(:lookup_key).with(@test_key).and_return([@test_value, (Time.now - Persistent::Cache::FRESH).to_s])
+      expect(Persistent::StorageRAM).to receive(:new).and_return(@mock_storage)
+
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache[@test_key]
+    end
+
+    it "should return nil if a key is not in the database" do
+      @pcache = Persistent::Cache.new(@db_name)
+      result = @pcache["thiskeydoesnotexist"]
+      expect(result.nil?).to eq(true)
+    end
+
+    it "should serialize the key for lookup" do
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache["testkey"] = "testvalue"
+      expect(@pcache).to receive(:lookup_key).with("testkey")
+      @pcache["testkey"]
+    end
+  end
+
+  context "it should behave like a cache" do
+    it "should return the correct size" do
+      setup_cache
+      expect(@pcache.size).to eq(3)
+    end
+
+    it "should return the list of keys when asked" do
+      setup_cache
+      expect(@pcache.keys[0].sort).to eq(["two", "one", "three"].sort)
+    end
+
+    it "should allow iteration through each" do
+      setup_cache
+      test = []
+      @pcache.each do |key, value|
+        test << "#{key} => #{value}"
+      end
+      expect(test).to eq(["[\"one\", \"two\", \"three\"] => "])
+    end
+
+    it "should delete all entries in the database when asked to clear" do
+      setup_cache
+      @pcache.clear
+      expect(@pcache.size).to eq(0)
+    end
+
+    it "should be able to handle multiple accesses to the same db" do
+      #pending "find a better way to test this, currently you need to spawn multiple rspecs running this test to hit the error if the busy_timeout is not specified"
+      pcache = Persistent::Cache.new("multidb") 
+      pcache["multi_test"] = 0
+
+      threads = []
+      100.times do |i|
+        threads << Thread.new do
+          Thread.current['pcache'] = Persistent::Cache.new("multidb") 
+          if (!Thread.current['pcache'].nil? && !Thread.current['pcache']["multi_test"].nil?)
+            Thread.current['pcache']["multi_test"] += 1
+          end
+        end
+      end
+      threads.each { |t| t.join }
+
+      p pcache["multi_test"]
+      
+    end
+
+    def setup_cache
+      FileUtils.rm_f(@db_name)
+      @pcache = Persistent::Cache.new(@db_name)
+      @pcache["one"] = "value one"
+      @pcache["two"] = "value two"
+      @pcache["three"] = "value three"
+    end
+  end
+
+  context "when needing to know if a key is in the cache" do
+    it "should return nil if the key is not present" do
+      setup_cache
+      expect(@pcache.key?(1)).to eql(nil)
+    end
+
+    it "should return the key if the key is present" do
+      setup_cache
+      @pcache[1] = "1"
+      expect(@pcache.key?(1)).to eql(1)
+    end
+
+    it "should return the key even if the entry is stale" do
+      setup_cache
+      @pcache[1] = "1"
+      sleep 2
+      expect(@pcache.key?(1)).to eql(1)
+      expect(@pcache[1]).to eql(nil)
+    end
+
+    def setup_cache(encoding = nil)
+      FileUtils.rm_f(@db_name)
+      @pcache = Persistent::Cache.new(@db_name, 1)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+require 'rspec'
+require 'rspec/mocks'
+require 'tempfile'
+require 'simplecov'
+require 'simplecov-rcov'
+#require 'debugger'
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'persistent-cache'))
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  #config.expect_with(:rspec) { |c| c.syntax = :should }
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+
+SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+def get_database_name
+  path = Tempfile.new("persistent-cache-spec-testdb").path
+  FileUtils.rm_f(path)
+  path
+end
+

data/spec/storage/storage_ram_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+require "persistent-cache/storage/storage_ram"
+
+describe Persistent::StorageRAM do
+  before :each do
+    @test_key = "testkey"
+    @test_value = "testvalue"
+    @iut = Persistent::StorageRAM.new
+  end
+
+  context "when constructed" do
+    it "should have a storage hash in RAM" do
+      expect(@iut.storage.nil?).to eql(false)
+      expect(@iut.storage.instance_of?(Hash)).to eql(true)
+    end
+  end
+
+  context "when asked to store a key value pair" do
+    it "should store the key/value pair in RAM, with the current time as timestamp" do
+      start_time = Time.now - 1
+      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result[0]).to eql(Marshal.dump(@test_value))
+      test_time = Time.parse(result[1])
+      expect(test_time).to be > start_time
+      expect(test_time).to be < start_time + 600
+    end
+
+    it "should store the key/value pair in RAM, with a timestamp specified" do
+      test_time = (Time.now - 2500)
+      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value), test_time)
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result.nil?).to eql(false)
+      expect(result[0]).to eql(Marshal.dump(@test_value))
+      time_retrieved = Time.parse(result[1])
+      expect(time_retrieved.to_s).to eql(test_time.to_s)
+    end
+
+    it "should overwrite the existing key/value pair if they already exist" do
+      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
+      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump("testvalue2"))
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result[0]).to eql(Marshal.dump("testvalue2"))
+    end
+  end
+
+  context "When looking up a value given its key" do
+    it "should retrieve the value from RAM" do
+      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result[0]).to eql(Marshal.dump(@test_value))
+    end
+
+    it "should retrieve the timestamp when the value was stored from RAM" do
+      now = Time.now.to_s
+      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
+      sleep 1
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result[1]).to eql(now)
+    end
+
+    it "should return an empty array if a key is not in RAM" do
+      @iut.delete_entry(Marshal.dump(@test_key))
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result).to eql([])
+      expect(result[0]).to eql(nil)
+    end
+  end
+
+  context "when asked to delete an entry" do
+    it "should not raise an error if the entry is not present" do
+      @iut.delete_entry(Marshal.dump("shouldnotbepresent"))
+    end
+
+    it "should delete the entry if it is present" do
+      @iut.save_key_value_pair(Marshal.dump(@test_key), Marshal.dump(@test_value))
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result[0]).to eql(Marshal.dump(@test_value))
+      @iut.delete_entry(Marshal.dump(@test_key))
+      result = @iut.lookup_key(Marshal.dump(@test_key))
+      expect(result).to eql([])
+    end
+  end
+
+  context "when asked the size of the RAM database" do
+    it "should return 0 if the RAM database has no entries" do
+      expect(@iut.size).to eql(0)
+    end
+
+    it "should return the number of entries" do
+      populate_database(@iut)
+      expect(@iut.size).to eql(3)
+    end
+  end
+
+  context "when asked for the keys in the RAM database" do
+    it "should return an empty array if there are no entries in the RAM database" do
+      expect(@iut.keys).to eql([])
+    end
+
+    it "should return the keys in the RAM database" do
+      populate_database(@iut)
+      keys = @iut.keys.flatten
+      expect(keys.include?(Marshal.dump("one"))).to eql(true)
+      expect(keys.include?(Marshal.dump("two"))).to eql(true)
+      expect(keys.include?(Marshal.dump("three"))).to eql(true)
+      expect(@iut.size).to eql(3)
+    end
+
+    it "should return the keys in an array, with each key in its own sub-array" do
+      populate_database(@iut)
+      found = false
+      test = Marshal.dump("one")
+      found = true if (@iut.keys[0][0] == test or @iut.keys[0][1] == test or @iut.keys[0][2] == test)
+      expect(found).to eql(true)
+    end
+  end
+
+  context "when asked to clear the RAM database" do
+    it "should delete all entries in RAM" do
+      populate_database(@iut)
+      @iut.clear
+      expect(@iut.size).to eql(0)
+    end
+  end
+
+  def populate_database(iut)
+    iut.save_key_value_pair(Marshal.dump("one"), Marshal.dump("one"))
+    iut.save_key_value_pair(Marshal.dump("two"), Marshal.dump("two"))
+    iut.save_key_value_pair(Marshal.dump("three"), Marshal.dump("three"))
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: persistent-cache-ram
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- Ernst van Graan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: eh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Persistent Cache limited to STORAGE_RAM
+email:
+- ernst.van.graan@hetzner.co.za
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/persistent-cache.rb
+- lib/persistent-cache/storage/storage_ram.rb
+- lib/persistent-cache/version.rb
+- persistent-cache-ram.gemspec
+- spec/persistent-cache_spec.rb
+- spec/spec_helper.rb
+- spec/storage/storage_ram_spec.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Persistent Cache limited to STORAGE_RAM
+test_files:
+- spec/persistent-cache_spec.rb
+- spec/spec_helper.rb
+- spec/storage/storage_ram_spec.rb
+has_rdoc: