caches 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: dc1818f0238ced3bc043d36e2e5630c7428fbad3
+  data.tar.gz: 5e7f76557165b0c31e62fc52dbc8515943e983fd
+!binary "U0hBNTEy":
+  metadata.gz: 8a7712863a9cdd2b4fbfc74f8b5898f279857d204677b5ba4ba26be846045fafd8c5932025e218ccd1cae34e5c0c927e95afd3c38de3e3bc5bd0581f075b8a0d
+  data.tar.gz: 874d0aa83657382395ac5ae9ce1df07447ebf45158456dac1051225106a186c819b150df963eeccb78027b454e7895c5a93a5c681e3e2c6681181703b26eb5ba

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.ruby-version
+.ruby-gemset

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Nathan Long
+
+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,85 @@
+# `caches`
+
+`caches` is a Ruby gem, providing a small collection of caches with good performance and hash-like access patterns. Each is named for its cache expiration strategy - when it will drop a key.
+
+## Usage
+
+`caches` provides the following classes.
+
+### Caches::TTL
+
+TTL (Time To Live) remembers values for as many seconds as you tell it. The default is 3600 seconds (1 hour).
+
+```ruby
+require 'caches/ttl'
+
+h = Caches::TTL.new(ttl: 5)
+h[:a] = 'aardvark'
+h[:a] #=> 'aardvark'
+sleep(6)
+h[:a] #=> nil
+```
+
+If you pass `refresh: true`, reading a value will reset its timer; otherwise, only writing will.
+
+The `memoize` method fetches a key if it exists and isn't expired; otherwise, it calculates the value using the block and saves it.
+
+```ruby
+h = Caches::TTL.new(ttl: 5)
+
+# Runs the block
+h.memoize(:a) { |k| calculation_for(k) }
+
+# Returns the previously-calculated value
+h.memoize(:a) { |k| calculation_for(k) }
+
+sleep(6)
+
+# Runs the block
+h.memoize(:a) { |k| calculation_for(k) }
+```
+
+### Caches::LRU
+
+LRU (Least Recently Used) remembers as many keys as you tell it to, dropping the least recently used key on each insert after its limit is reached.
+
+```ruby
+require 'caches/lru'
+h = Caches::LRU.new(max_keys: 3)
+h[:a] = "aardvark"
+h[:b] = "boron"
+h[:c] = "cattail"
+h[:d] = "dingo"
+puts h[:a] # => nil
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'caches'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install caches
+
+## Coming Soon
+
+Other classes with different cache expiration strategies.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+# Thanks
+
+- Thanks to [FromAToB.com](http://www.fromatob.com) for giving me time to make this
+- Thanks to [satyap](https://github.com/satyap); the original specs for `caches` were adapted from [volatile_hash](https://github.com/satyap/volatile_hash).

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+desc "Run the specs in documentation format"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--format documentation'
+end
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'caches/all'
+  ARGV.clear
+  IRB.start
+end
+
+task :default => :spec

data/TODO.md

@@ -0,0 +1,29 @@
+# TODO
+
+## General
+
+- Refactor LinkedList
+- Add benchmarks: speed (and maybe memory usage), runnable with rake task for all cache classes. Be able to compare over the course of development (eg, version 0.0.1 vs 0.0.3). Maybe output ASCII graphs for fun.
+- Add Travis CI testing
+- Give all caches a way to manually invalidate a given key. Return nil if it wasn't here and the value if it was.
+- Add "least used" cache class
+- Define `blank?`, etc on list and caches
+- Should TTL keys be renewed by updates? LRU ones aren't. If the cache exists to be read, probably not.
+- Ride a skateboard and, simultaneously, shoot a potato gun
+
+## New types
+
+Build LU - Least Used. Expiration criteria is essentially "uses per second" - reads divided by time since write.
+
+Implementation ideas:
+  - Passage of time doesn't change ranking of keys; only writing does.
+  - Keep a doubly-linked list of keys ordered by usefulness and a reference to the tail for easy dropping
+  - When updating a key, be able to quickly compare it with the one ahead of it and swap if it overtook it in rank
+  - Normal hash data structure has pointers into linked list segments
+
+
+## Benchmarks
+
+TTL: Prepopulate instances differing in size by orders of magnitude. Measure N operations of various types. These vary on three axes: read/write, expired/fresh, and update/insert for writes. Output results as graph. Visually confirm that it appears O(1) and is reasonably fast (?) in absolute terms.
+
+LRU: ?

data/caches.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'caches/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "caches"
+  spec.version       = Caches::VERSION
+  spec.authors       = ["Nathan Long"]
+  spec.email         = ["nathanmlong@gmail.com"]
+  spec.description   = %q{A small collection of hashes that cache}
+  spec.summary       = %q{A small collection of hashes that cache}
+  spec.homepage      = "https://github.com/nathanl/caches"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec",   "~> 2.14"
+
+end

data/lib/caches/accessible.rb

@@ -0,0 +1,19 @@
+module Caches
+  module Accessible
+
+    def fetch(key, default = (default_omitted = true; nil))
+      return self[key]  if data.has_key?(key)
+      return yield(key) if block_given?
+      return default    unless default_omitted
+      raise KeyError
+    end
+
+    def memoize(key)
+      raise ArgumentError, "Block is required" unless block_given?
+      self[key] # triggers flush or refresh if expired
+      return self[key]       if data.has_key?(key)
+      self[key] = yield(key) if block_given?
+    end
+
+  end
+end

data/lib/caches/all.rb

@@ -0,0 +1,2 @@
+require_relative 'ttl'
+require_relative 'lru'

data/lib/caches/linked_list.rb

@@ -0,0 +1,115 @@
+module Caches
+  # This LinkedList class is unusual in that it gives direct access to its nodes.
+  # It trusts the user not to break it! The advantage is that outsiders with
+  # a node reference can reorder the list (eg, using #move_to_head) in O(1) time.
+  class LinkedList
+    include Enumerable
+
+    attr_reader :length
+
+    def initialize(item = nil)
+      if item
+        Node.new(item).tap { |node|
+          self.head   = self.tail = node
+          self.length = 1
+        }
+      else
+        self.length = 0
+      end
+    end
+
+    def each
+      current = head
+      while current do
+        yield(current.value)
+        current = current.right
+      end
+    end
+
+    def append(item)
+      return initialize(item) if empty?
+      Node.new(item, left: tail).tap { |new_tail|
+        tail.right = new_tail
+        self.tail  = new_tail
+        self.length = length + 1
+      }
+    end
+
+    def prepend(item)
+      return initialize(item) if empty?
+      Node.new(item, right: head).tap { |new_head|
+        head.left = new_head
+        self.head = new_head
+        self.length = length + 1
+      }
+    end
+    alias :unshift :prepend
+
+    def pop
+      tail.tap {
+        new_tail       = tail.left
+        new_tail.right = nil
+        self.tail      = new_tail
+        self.length = length - 1
+      }
+    end
+
+    def lpop
+      head.tap {
+        new_head      = head.right
+        new_head.left = nil
+        self.head     = new_head
+        self.length = length - 1
+      }
+    end
+    alias :shift :lpop
+
+    def move_to_head(node)
+      excise(node)
+      node.right = head
+      self.head  = node
+    end
+
+    def empty?
+      length == 0
+    end
+
+    # TODO - move these to a module and use in caches, too
+    alias :blank? :empty?
+    def present?
+      !empty?
+    end
+    def presence
+      self if present?
+    end
+
+    private
+    attr_accessor :head, :tail
+    attr_writer   :length
+
+    def excise(node)
+      raise InvalidNode unless node.is_a?(Node)
+      left       = node.left
+      right      = node.right
+      left.right = right unless left.nil?
+      right.left = left  unless right.nil?
+      self.head  = right if head == node
+      self.tail  = left  if tail == node
+      node
+    end
+
+    class Node
+      attr_accessor :value, :right, :left
+      def initialize(value, pointers = {})
+        self.value = value
+        self.right = pointers[:right]
+        self.left  = pointers[:left]
+      end
+
+      def right?; !right.nil?; end
+      def left?;  !left.nil?   end
+    end
+
+    InvalidNode = Class.new(StandardError)
+  end
+end

data/lib/caches/lru.rb

@@ -0,0 +1,47 @@
+require_relative 'accessible'
+require_relative 'linked_list'
+
+module Caches
+  class LRU
+    include Accessible
+    attr_accessor :max_keys
+
+    def initialize(options = {})
+      self.max_keys = options.fetch(:max_keys, 20)
+      self.data     = {}
+      self.keys = LinkedList.new
+    end
+
+    def [](key)
+      return nil unless data.has_key?(key)
+      value, node = data[key]
+      keys.move_to_head(node)
+      value
+    end
+
+    def []=(key, val)
+      if data.has_key?(key)
+        data[key][0] = val
+      else
+        node = keys.prepend(key)
+        data[key] = [val, node]
+      end
+      prune
+      val
+    end
+
+    def size
+      keys.length
+    end
+
+    private
+    attr_accessor :keys, :data
+
+    def prune
+      return unless keys.length > max_keys
+      expiring_node = keys.pop
+      data.delete(expiring_node.value)
+    end
+
+  end
+end

data/lib/caches/ttl.rb

@@ -0,0 +1,42 @@
+require_relative 'accessible'
+
+module Caches
+  class TTL
+    include Accessible
+    attr_accessor :ttl, :refresh
+
+    def initialize(options = {})
+      self.ttl     = options.fetch(:ttl) { 3600 }
+      self.refresh = !!(options.fetch(:refresh, false))
+      self.data    = {}
+    end
+
+    def [](key)
+      return nil unless data.has_key?(key)
+      if (current_time - data[key][:time]) < ttl
+        data[key][:time] = current_time if refresh
+        data[key][:value]
+      else
+        data.delete(key)
+        nil
+      end
+    end
+
+    def []=(key, val)
+      data[key] = {time: current_time, value: val}
+    end
+
+    def size
+      data.keys.length
+    end
+
+    private
+
+    attr_accessor :data
+
+    def current_time
+      Time.now
+    end
+
+  end
+end

data/lib/caches/version.rb

@@ -0,0 +1,3 @@
+module Caches
+  VERSION = "0.0.1"
+end

data/lib/caches.rb

@@ -0,0 +1,5 @@
+require 'time'
+require "caches/version"
+
+module Caches
+end

data/spec/fetch_examples.rb

@@ -0,0 +1,24 @@
+shared_examples "fetch" do
+
+  it "returns the value if an existing key is accessed" do
+    expect(cache.fetch(:c)).to eq('Caspian')
+  end
+
+  it "raises an error if a missing key is accessed" do
+    expect{cache.fetch(:nonexistent)}.to raise_error(KeyError)
+  end
+
+  it "uses a default value if one is supplied" do
+    expect(cache.fetch(:nonexistent, 'hi')).to eq('hi')
+  end
+
+  it "gets its default from a block if one is supplied" do
+    expect(cache.fetch(:nonexistent) { |key| key.to_s.upcase }).to eq('NONEXISTENT')
+  end
+
+  it "prefers a block value to an immediate one (like native hashes do)" do
+    expect(cache.fetch(:nonexistent, 'hi') { |key| key.to_s.upcase }).to eq('NONEXISTENT')
+  end
+
+end
+

data/spec/hash_cache/linked_list_spec.rb

@@ -0,0 +1,120 @@
+require          'spec_helper'
+require_relative '../../lib/caches/linked_list'
+
+describe Caches::LinkedList do
+
+  let(:empty_list) { described_class.new }
+  let(:list)       { described_class.new('lemur') }
+  let(:node_class) { Caches::LinkedList::Node }
+
+  it "can convert itself to an array of values" do
+    expect(list.to_a).to eq(['lemur'])
+  end
+
+  describe '#append' do
+
+    it "adds an item to the end" do
+      list.append('wombat')
+      expect(list.to_a).to eq(['lemur', 'wombat'])
+    end
+
+    it "returns a Node" do
+      node = list.append('wombat')
+      expect(node).to be_a(node_class)
+    end
+
+    it "sets up the list correctly if it was empty to start with" do
+      empty_list.append('jimmy')
+      expect{empty_list.prepend('jammy')}.not_to raise_error
+    end
+
+  end
+
+  describe "#prepend" do
+
+    it "adds an item to the beginning" do
+      list.prepend('vole')
+      expect(list.to_a).to eq(['vole', 'lemur'])
+    end
+
+    it "returns a Node" do
+      node = list.prepend('vole')
+      expect(node).to be_a(node_class)
+    end
+
+    it "sets up the list correctly if it was empty to start with" do
+      empty_list.prepend('jimmy')
+      expect{empty_list.append('jammy')}.not_to raise_error
+    end
+
+  end
+
+  it "knows its length" do
+    expect(list.length).to eq(1)
+    list.append('wombat')
+    list.prepend('vole')
+    expect(list.length).to eq(3)
+  end
+
+  describe "#move_to_head" do
+
+    context "when the argument is a Node" do
+
+      it "makes it the new head" do
+        list.append('mittens')
+        node = list.append('cozy')
+        list.move_to_head(node)
+        expect(list.to_a).to eq(%w[cozy lemur mittens])
+      end
+
+    end
+
+    context "when the argument is not a Node" do
+
+      it "raises an error" do
+        list.append('cozy')
+        expect{list.move_to_head('super duper')}.to raise_error(Caches::LinkedList::InvalidNode)
+      end
+
+    end
+
+  end
+
+  context "when there's more than one item" do
+
+    let(:list) {
+      list = described_class.new('lemur')
+      list.append('muskrat')
+      list
+    }
+
+    describe "#pop" do
+
+      it "removes the last item" do
+        list.pop
+        expect(list.to_a).to eq(['lemur'])
+      end
+
+      it "returns a node" do
+        expect(list.pop).to be_a(node_class)
+      end
+
+    end
+
+
+    describe "#lpop" do
+
+      it "removes the first item" do
+        list.lpop
+        expect(list.to_a).to eq(['muskrat'])
+      end
+
+      it "returns a node" do
+        expect(list.lpop).to be_a(node_class)
+      end
+
+    end
+
+  end
+
+end

data/spec/hash_cache/lru_spec.rb

@@ -0,0 +1,108 @@
+require          'spec_helper'
+require          'fetch_examples'
+require_relative '../../lib/caches/lru'
+
+describe Caches::LRU do
+
+  let(:options) { {max_keys: 4} }
+  let(:cache)   {
+    described_class.new(options).tap {|c|
+      c[:a] = 'Alambil'
+      c[:b] = 'Belisar'
+      c[:c] = 'Caspian'
+    }
+  }
+
+  it "remembers its values" do
+    expect(cache[:a]).to eq('Alambil')
+    expect(cache[:b]).to eq('Belisar')
+    expect(cache[:c]).to eq('Caspian')
+  end
+
+  it "can report its size" do
+    expect(cache.size).to eq(3)
+  end
+
+  it "can grow up to the max size given" do
+    cache[:d] = 'Destrier'
+    expect(cache.size).to eq(4)
+  end
+
+  it "does not grow beyond the max size given" do
+    cache[:d] = 'Destrier'
+    cache[:e] = 'Erimon'
+    expect(cache.size).to eq(4)
+  end
+
+  it "drops the least-recently accessed key" do
+    cache[:d] = 'Destrier'
+    cache[:e] = 'Erimon'
+    expect(cache[:a]).to be_nil
+  end
+
+  it "counts a read as access" do
+    cache[:d] = 'Destrier'
+    cache[:a]
+    cache[:e] = 'Erimon'
+    expect(cache[:a]).to eq('Alambil')
+    expect(cache[:b]).to be_nil
+  end
+
+  include_examples "fetch"
+
+  describe "memoize" do
+
+    it "requires a block" do
+      expect{cache_memoize(:c)}.to raise_error
+    end
+
+    let(:greeting) { 'hi' }
+
+    context "when the key already exists" do
+
+      it "does not calculate the value" do
+        expect(greeting).not_to receive(:upcase)
+        cache.memoize(:c) { greeting.upcase }
+      end
+
+    end
+
+    context "when the key has not been set" do
+
+      let(:key) { :nonexistent }
+
+      it "calculates the value" do
+        expect(greeting).to receive(:upcase)
+        cache.memoize(:nonexistent) { greeting.upcase }
+      end
+
+      it "sets the value" do
+        cache.memoize(:nonexistent) { greeting.upcase }
+        expect(cache[:nonexistent]).to eq(greeting.upcase)
+      end
+
+    end
+
+    context "when the key has been dropped" do
+
+      before :each do
+        cache[:d] = 'Destrier'
+        cache[:e] = 'Erimon'
+      end
+
+      it "calculates the value" do
+        expect(greeting).to receive(:upcase)
+        cache.memoize(:a) { greeting.upcase }
+      end
+
+      it "sets the value" do
+        cache.memoize(:a) { greeting.upcase }
+        expect(cache[:a]).to eq(greeting.upcase)
+      end
+
+    end
+
+  end
+
+end
+

data/spec/hash_cache/ttl_spec.rb

@@ -0,0 +1,141 @@
+require          'spec_helper'
+require          'fetch_examples'
+require_relative '../../lib/caches/ttl'
+
+describe Caches::TTL do
+
+  let(:options) { {} }
+  let(:cache)   {
+    described_class.new(options).tap {|c|
+      c[:c] = 'Caspian'
+      c.stub(:current_time).and_return(start_time)
+    }
+  }
+
+  let(:start_time) { Time.now }
+  let(:before_ttl) { start_time + 1800 }
+  let(:after_ttl)  { start_time + 3601 }
+
+  it "can report its size" do
+    expect(cache.size).to eq(1)
+  end
+
+  it "remembers cached values before the TTL expires" do
+    expect(cache[:c]).to eq('Caspian')
+    cache.stub(:current_time).and_return(before_ttl)
+    expect(cache[:c]).to eq('Caspian')
+  end
+
+  it "forgets cached values after the TTL expires" do
+    expect(cache[:c]).to eq('Caspian')
+    cache.stub(:current_time).and_return(after_ttl)
+    expect(cache[:c]).to be_nil
+  end
+
+  it "continues returning nil for cached values after the TTL expires" do
+    expect(cache[:c]).to eq('Caspian')
+    cache.stub(:current_time).and_return(after_ttl)
+    expect(cache[:c]).to be_nil
+    expect(cache[:c]).to be_nil
+  end
+
+  it "resets TTL when an item is updated" do
+    cache.stub(:current_time).and_return(before_ttl)
+    cache[:c] = 'Cornelius'
+    cache.stub(:current_time).and_return(after_ttl)
+    expect(cache[:c]).to eq('Cornelius')
+  end
+
+  it "doesn't reset TTL when an item is accessed" do
+    cache.stub(:current_time).and_return(before_ttl)
+    expect(cache[:c]).to eq('Caspian')
+    cache.stub(:current_time).and_return(after_ttl)
+    expect(cache[:c]).to be_nil
+  end
+
+  context "when asked to refresh TTL on access" do
+
+    let(:options) { {refresh: true} }
+
+    it "keeps values that were accessed before the TTL expired" do
+      cache.stub(:current_time).and_return(before_ttl)
+      expect(cache[:c]).to eq('Caspian')
+      cache.stub(:current_time).and_return(after_ttl)
+      expect(cache[:c]).to eq('Caspian')
+    end
+
+  end
+
+  include_examples "fetch"
+
+  describe "memoize" do
+
+    it "requires a block" do
+      expect{cache_memoize(:c)}.to raise_error
+    end
+
+    let(:greeting) { 'hi' }
+
+    context "when the key already exists" do
+
+      context "before the TTL is up" do
+
+        it "returns the existing value" do
+          expect(cache.memoize(:c) { 'Eustace' } ).to eq('Caspian')
+        end
+
+        it "does not calculate the value" do
+          cache.stub(:current_time).and_return(before_ttl)
+          expect(greeting).not_to receive(:upcase)
+          cache.memoize(:c) { greeting.upcase }
+        end
+
+      end
+
+      context "after the TTL is up" do
+
+        it "recalculates the value" do
+          cache.stub(:current_time).and_return(after_ttl)
+          expect(greeting).to receive(:upcase)
+          cache.memoize(:c) { greeting.upcase }
+        end
+
+        it "returns the calculated value" do
+          cache.stub(:current_time).and_return(after_ttl)
+          expect(cache.memoize(:c) { |key| key.to_s.upcase }).to eq('C')
+        end
+
+      end
+
+    end
+
+    context "when the key does not exist" do
+
+      it "calculates the value" do
+        expect(greeting).to receive(:upcase)
+        cache.memoize(:nonexistent) { greeting.upcase }
+      end
+
+      it "returns the value" do
+        expect(cache.memoize(:nonexistent) { |key| key.to_s.upcase }).to eq('NONEXISTENT')
+      end
+
+      it "does not calculate the value again within the TTL" do
+        cache.memoize(:nonexistent) { greeting.upcase }
+        cache.stub(:current_time).and_return(before_ttl)
+        expect(greeting).not_to receive(:upcase)
+        cache.memoize(:nonexistent) { greeting.upcase }
+      end
+
+      it "does calculate the value again after the TTL is up" do
+        cache.memoize(:nonexistent) { greeting.upcase }
+        cache.stub(:current_time).and_return(after_ttl)
+        expect(greeting).to receive(:upcase)
+        cache.memoize(:nonexistent) { greeting.upcase }
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'bundler/setup'
+
+RSpec.configure do |config|
+  config.order = :random
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: caches
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nathan Long
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.14'
+description: A small collection of hashes that cache
+email:
+- nathanmlong@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO.md
+- caches.gemspec
+- lib/caches.rb
+- lib/caches/accessible.rb
+- lib/caches/all.rb
+- lib/caches/linked_list.rb
+- lib/caches/lru.rb
+- lib/caches/ttl.rb
+- lib/caches/version.rb
+- spec/fetch_examples.rb
+- spec/hash_cache/linked_list_spec.rb
+- spec/hash_cache/lru_spec.rb
+- spec/hash_cache/ttl_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/nathanl/caches
+licenses:
+- MIT
+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.0.14
+signing_key: 
+specification_version: 4
+summary: A small collection of hashes that cache
+test_files:
+- spec/fetch_examples.rb
+- spec/hash_cache/linked_list_spec.rb
+- spec/hash_cache/lru_spec.rb
+- spec/hash_cache/ttl_spec.rb
+- spec/spec_helper.rb