quandl_location 0.1.1

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+script: bundle exec rspec

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# quandl_location changelog
+
+## 0.1.1
+
+* Update gemspec.
+
+## 0.1.0
+
+* Initial release.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Jason Byck
+
+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,98 @@
+# Quandl Location
+
+[![Build Status](https://magnum.travis-ci.com/quandl/quandl_location.png?token=Jqe6yYPbokJgKw6u73eU&branch=master)](https://magnum.travis-ci.com/quandl/quandl_location)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'quandl_location'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quandl_location
+    
+  
+## About
+
+quandl_location provides a getter/setter class to store key-value data, but abstracts the storage engine used to store the data. 
+
+Any supported storage engine can be configured at run time.  Currently supports Redis and Unix file system.
+
+
+## Usage
+
+
+
+#### Configure Redis storage
+
+``` ruby
+Quandl::Location.use(:redis) do
+  with_options { host: localhost, port: 6379 }
+end
+```
+Redis storage takes two optional configuration settings: expiry and encoding.
+
+For example:
+
+```yaml
+production:
+  host: localhost
+  port: 6379
+  expiry: 3600
+  encoding: ASCII-8BIT
+```
+
+This configuration will set a timeout of 1 day for each key in Redis created by Quandl::Location, and force the encoding for all retreived objects to 'ASCII-8BIT'.
+
+There is no default expiry.  If it is not included in configuration, then no timeout will be set for the created key.
+
+If encoding is not included, retrieved data from Redis will be encoded with Encoding::default_external (which is default behaviour of the redis-rb gem).
+
+#### Configure file system storage
+
+``` ruby
+Quandl::Location.use(:file_system) do
+  with_options { data_dir: '/data/locations/' }
+end
+```
+
+File system stores location data using the location_id as the file name.
+
+#### Save data
+
+Creates new key, or overwrites existing key with new data.
+
+``` ruby
+location_data = Quandl::Location::Data.find(location_id)
+location_data.data = [1,2,3]
+location_data.save
+```
+#### Retrieve data
+
+Returns the data, or returns nil if data does not exist.
+
+```ruby
+raw_data = Quandl::Location::Data.find(location_id).data
+```
+
+#### Check for data
+
+Use exists? method to check if the data exits in the storage engine. The get method returns nil if exists? is false, so it is not necessary to check for existance before using get.
+
+Quandl::Storage::Redis returns true if there is a key with value location_id, and Quandl::Storage::FileSystem returns true if there is a file present with name location_id.
+
+```ruby
+location_data = Quandl::Location::Data.find(new_location_id)
+location_data.exists?
+=> false
+location_data.data = [1,2,3]
+location_data.exists?
+=> false
+location_data.save
+location_data.exists?
+=> true

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/quandl/location.rb

@@ -0,0 +1,65 @@
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/inflector'
+
+require 'quandl/location/exceptions'
+require 'quandl/location/data'
+require 'quandl/location/storage'
+
+module Quandl
+  module Location
+    
+    STORAGE_ENGINES = [:redis, :file_system]
+        
+    class << self
+      
+      # The list of supported storage engines for locations
+      #
+      # Returns array
+      def storage_engines
+        STORAGE_ENGINES
+      end
+      
+      # The name of the current active storage engine, or nil if not set
+      #
+      # Returns string or nil
+      def storage_engine_type
+        @@storage_engine_type || nil
+      end
+      
+      # Set the storage engine for the location module
+      #
+      # Returns Quandl::Location::Storage 
+      # Raises  Quandl::Location::UnknownStorageEngineError
+      def use(storage_engine, &block)
+        unless storage_engines.include?(storage_engine.to_sym)
+          error_message = %Q{
+            Unknown storage engine #{storage_engine}.
+            Please use one of supported engines #{storage_engines.collect{|s| s.to_s}.join}
+          }
+          raise(Quandl::Location::UnknownStorageEngineError, error_message)
+        end
+        @@storage_engine_type = storage_engine
+        storage_engine_class = storage_engine.to_s.downcase.camelize
+        @@storage_engine = "Quandl::Location::Storage::#{storage_engine_class}".constantize.new
+        @@storage_engine.instance_eval(&block) if block_given?
+      end
+ 
+      
+      # The intance of the Storage class that was configured
+      #
+      # Returns Quandl::Location::Storage
+      # Raises  Quandl::Location::UninitializedStorageEngineError
+      def storage_engine
+        unless @@storage_engine.present?
+          raise(Quandl::Location::UninitializedStorageEngineError, "You must configure a valid storage engine.")
+        end
+        @@storage_engine
+      end
+      
+    end
+    
+  end
+end
+

data/lib/quandl/location/data.rb

@@ -0,0 +1,77 @@
+module Quandl
+  module Location
+    class Data
+      
+      class << self
+        
+        # Create a new location data instance
+        #
+        # id - The location id 
+        # 
+        # Returns Quandl::Location::Data 
+        def find(id)
+          self.new(id)
+        end
+        
+      end
+      
+      attr_accessor :id, :data
+      
+      # Constructor
+      #
+      # Returns Quandl::Location::Data
+      def initialize(*args)
+        self.id = args.first
+      end
+      
+      # Set the data for the location, through the storage engine
+      #
+      # data - The raw location data as a string
+      #
+      # Returns .
+      def data=(data)
+        @raw_data = data
+        @data_changed = true
+      end
+      
+      # Get the location data, through the storage engine
+      #
+      # Returns string
+      def data
+        storage.get(id)
+      end
+      
+      # Has the raw data changed
+      #
+      # Return boolean
+      def changed?
+        @data_changed == true
+      end
+      
+      # Save the raw_data that was set through data=
+      #
+      # Returns boolean
+      def save
+        return false unless @data_changed
+        storage.set(id, @raw_data)
+      end
+      
+      # Check if data exists in storage engine
+      #
+      # Return boolean
+      def exists?
+        storage.exists?(id)
+      end
+      
+      protected
+      
+      # Access to currently configured storage engine
+      #
+      # Returns Quandl::Location::Storage
+      def storage
+        @storage ||= Quandl::Location.storage_engine
+      end
+            
+    end
+  end
+end

data/lib/quandl/location/exceptions.rb

@@ -0,0 +1,24 @@
+module Quandl
+  module Location
+  
+    # Unknown storage engine
+    class UnknownStorageEngineError < RuntimeError; end
+  
+    # Storage not initialized
+    class UninitializedStorageEngineError < RuntimeError; end
+    
+    # Storage options
+    class InvalidStorageOptionsError < RuntimeError; end
+    
+    # Storage engine not complete
+    class IncompleteStorageEngineError < RuntimeError; end
+    
+    # Locaiton data not present when expected
+    class MissingLocationDataError < RuntimeError; end
+    
+    # Bad storage configuration
+    class StorageConfigurationError < RuntimeError; end 
+    
+    
+  end
+end

data/lib/quandl/location/storage.rb

@@ -0,0 +1,48 @@
+module Quandl
+  module Location
+    
+    class Storage
+      
+      # Auto assign storage options from configuration
+      #
+      # storage_options - A hash of key value options to configure the storage engine
+      #
+      # Return nil
+      def with_options(storage_options)
+        unless storage_options.present? and storage_options.kind_of?(Hash)
+          raise(Quandl::Location::InvalidStorageOptionsError, "Storage options must be present and kind of Hash")
+        end
+        storage_options.collect do |k,v| 
+          self.send("#{k}=", v) if self.respond_to?("#{k}=")
+        end
+      end
+      
+      # Get the data from the storage engine
+      # This is a method stub that raises an error unless get has been implemented in the child class.
+      #
+      # Raises Quandl::Location::IncompleteStorageEngineError
+      def get
+        raise(Quandl::Location::IncompleteStorageEngineError, "get method must be implemented in class.")
+      end
+      
+      # Set the data in the storage engine
+      # This is a method stub that raises an error unless set has been implemented in the child class.
+      #
+      # Raises Quandl::Location::IncompleteStorageEngineError
+      def set
+        raise(Quandl::Location::IncompleteStorageEngineError, "set method must be implemented in class.")
+      end
+      
+      # Check if the location_id exists in the storage engine
+      # This is a method stub that raises an error unless set has been implemented in the child class.
+      def exists?
+        raise(Quandl::Location::IncompleteStorageEngineError, "exists? method must be implemented in class.")
+      end
+      
+    end
+    
+  end
+end
+
+require 'quandl/location/storage/file_system'
+require 'quandl/location/storage/redis'

data/lib/quandl/location/storage/file_system.rb

@@ -0,0 +1,43 @@
+module Quandl
+  module Location
+    
+    class Storage::FileSystem < Storage
+      
+      attr_accessor :data_dir
+          
+      def get(location_id)
+        return nil unless self.exists?(location_id)
+        file = File.open(location_file_name(location_id), 'rb')
+        file.read
+      end
+      
+      def set(location_id, data)
+        ensure_file_location_exists(location_id)
+        File.open(location_file_name(location_id), 'w') { |file| file.write(data) }
+        true
+      end
+      
+      def exists?(location_id)
+        File.exists?(location_file_name(location_id))
+      end
+      
+      protected
+      
+      def ensure_file_location_exists(location_id)
+        FileUtils.mkdir_p location_directory
+        FileUtils.touch   location_file_name(location_id.to_s)
+      end
+      
+      def location_directory
+        @location_directory ||= ::File.join(data_dir, 'location')
+      end
+      
+      def location_file_name(location_id)
+        File.join(location_directory, location_id.to_s)
+      end
+    
+    end
+    
+    
+  end
+end

data/lib/quandl/location/storage/redis.rb

@@ -0,0 +1,81 @@
+require 'redis'
+
+module Quandl
+  module Location
+   
+    class Storage::Redis < Storage
+            
+      attr_accessor :host, :port, :expiry, :encoding
+      
+      # Retrieve the Redis store location id
+      #
+      # Returns string
+      def get(location_id)
+        data = connection.get location_id
+        data.force_encoding(encoding) if encodable?
+        data
+      end
+      
+      # Save the data to Redis key location_id
+      # If Storage::Redis instance has expiry setting, then set expire time for the location
+      #
+      # Returns boolean
+      def set(location_id, data)
+        connection.set location_id, data
+        connection.expire(location_id, expiry) if expirable?
+        true
+      end
+      
+      # Check if key exists in Redis
+      #
+      # location_id - The Redis key to 
+      # 
+      # Returns boolean
+      def exists?(location_id)
+        connection.exists location_id
+      end
+      
+      # Establish a connection to redis
+      # 
+      # Returns boolean
+      def connect
+        connection
+        return true
+      end
+      
+      protected
+      
+      # Determines if Storage instance is configured to override default encoding
+      #
+      # Returns boolean
+      def encodable?
+        self.encoding.present? and self.encoding.kind_of?(String)
+      end
+      
+      # Determines if the Storage instance is configured to set TTL for keys
+      #
+      # Returns boolean
+      def expirable?
+        self.expiry.present? and self.expiry.kind_of?(Fixnum)
+      end
+      
+      # Return a Redis connection
+      # 
+      # Returns Redis::Client
+      # Raises Quandl::Location::StorageConfigurationError
+      def connection
+        unless @connection
+          unless host.present? and port.present?
+            raise(Quandl::Location::StorageConfigurationError, "Redis port and host required.")
+          end
+          @connection = ::Redis.new(host: host, port: port)
+        end
+        @connection
+      end
+      
+    end
+
+    
+  
+  end
+end

data/lib/quandl/location/version.rb

@@ -0,0 +1,5 @@
+module Quandl
+  module Location
+    VERSION = "0.1.1"
+  end
+end

data/quandl_location.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'quandl/location/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "quandl_location"
+  spec.version       = Quandl::Location::VERSION
+  spec.authors       = ["Jason Byck"]
+  spec.email         = ["jasonbyck@gmail.com"]
+  spec.description   = %q{Provides a library for accessing data from arbitrary key-value storage}
+  spec.summary       = %q{Abstracted key value storage library}
+  spec.homepage      = "https://github.com/quandl/quandl_location"
+
+  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 'rspec'
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "fakeredis"
+  
+  spec.add_runtime_dependency "redis"
+  spec.add_runtime_dependency "activesupport", "~> 3"
+end

data/spec/quandl/location/data_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Quandl::Location::Data do
+  
+  let(:location_id) { (1..1000).to_a.sample }
+  let(:fake_data) { (0...8).map { (65 + rand(26)).chr }.join }
+  let(:data_object) { Quandl::Location::Data.new(location_id) }
+  let(:storage_mock) { storage_double = double('Quandl::Location::Storage') }
+  
+  # Mock the storage implentation
+  before(:each) do
+    Quandl::Location::Data.any_instance.stub(:storage).and_return(storage_mock)
+  end
+
+  describe '#find' do
+    
+    it 'should return a new Quandl::Location::Data instance' do
+      Quandl::Location::Data.find(230).should be_kind_of(Quandl::Location::Data)
+    end
+    
+  end
+  
+  describe '#data=' do
+    
+    before(:each) do
+      data_object.data = fake_data
+    end
+
+    it 'assign the data to be saved as raw_data' do
+      data_object.instance_variable_get(:@raw_data).should be fake_data
+    end
+    
+    it 'should mark the data as changed' do
+      data_object.changed?.should be true
+    end
+    
+  end
+  
+  describe '#changed?' do
+    
+    subject { data_object }
+    
+    context 'data has been set' do
+      
+      before(:each) { subject.data = fake_data }
+      
+      its(:changed?) { should be true }
+      
+    end
+    
+    context 'data has not been set' do
+      
+      its(:changed?) { should be false }
+      
+    end
+    
+  end
+  
+  describe '#data' do
+    
+    it 'should request the data through the storage engine' do
+      storage_mock.should_receive(:get).with(location_id)
+      data_object.data
+    end
+  
+  end
+  
+  describe '#save' do
+    
+    context 'data is ready to be saved' do
+      
+      before(:each) { data_object.data = fake_data }
+      
+      it 'should persist data through the storage engine' do
+        storage_mock.should_receive(:set).with(location_id, fake_data)
+        data_object.save
+      end
+      
+    end
+    
+    context 'data is not ready to be saved' do
+      
+      it 'should return false' do
+        data_object.save.should be false
+      end
+      
+    end
+
+    
+  end
+  
+  describe '#exists?' do
+    
+    it 'should return status through storage engine' do
+      storage_mock.should_receive(:exists?).with(location_id)
+      data_object.exists?
+    end
+    
+  end
+  
+end

data/spec/quandl/location/storage/file_system_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Quandl::Location::Storage::FileSystem do
+  
+  let(:data_dir) { '/etc/data' }
+  let(:location_id) { (1..1000).to_a.sample }
+  let(:fake_data) { (0...8).map { (65 + rand(26)).chr }.join }
+  let(:file_storage) do
+    f = Quandl::Location::Storage::FileSystem.new
+    f.with_options({ data_dir: data_dir })
+    f
+  end
+  
+  it { should respond_to(:data_dir) }
+  
+  before(:each) do
+    FileUtils.stub(:touch).and_return(true)
+    FileUtils.stub(:mkdir_p).and_return(true)
+    File.stub(:open).and_return(double('File'))
+  end
+  
+  describe '#set' do
+    
+    it 'should ensure the file location exists before writing data' do
+      FileUtils.should_receive(:touch).once
+      file_storage.set(location_id, fake_data)
+    end
+    
+    it 'should return true if successful' do
+      file_storage.set(location_id, fake_data).should be true
+    end
+    
+  end
+  
+  describe '#exists?' do
+    
+    context 'location file exists' do
+      
+      before(:each) { File.stub(:exists?).and_return(true) }
+      
+      it 'should return true' do
+        file_storage.exists?(location_id).should be true
+      end
+      
+    end
+    
+    context 'location file does not exist' do
+      
+      before(:each) { File.stub(:exists?).and_return(false) }
+      
+      it 'should return false' do
+        File.stub(:exists?).and_return(false)
+        file_storage.exists?(location_id).should be false
+      end
+      
+    end
+    
+  end
+  
+  describe '#get' do
+    
+    context 'location file exists' do
+      
+      before(:each) do
+        File.stub(:exists?).and_return(true)
+        Object.any_instance.stub(:read).and_return(fake_data)
+      end 
+      
+      it 'should return the saved location data' do
+        file_storage.get(location_id).should be fake_data
+      end
+      
+    end
+    
+    context 'location file does not exist' do
+      
+      before(:each) do 
+        File.stub(:exists?).and_return(false)
+      end
+      
+      it 'should return nil' do
+        file_storage.get(location_id).should be nil
+      end
+      
+    end
+    
+  end
+  
+end
+

data/spec/quandl/location/storage/redis_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Quandl::Location::Storage::Redis do
+  
+  let(:redis_storage) do
+    r = Quandl::Location::Storage::Redis.new
+    r.with_options(host: 'localhost', port: 6379)
+    r
+  end
+  
+  let(:redis_storage_expiry) do
+    r = Quandl::Location::Storage::Redis.new
+    r.with_options(host: 'localhost', port: 6379, expiry: 1)
+    r
+  end
+  
+  let(:redis_storage_encoding) do
+    r = Quandl::Location::Storage::Redis.new
+    r.with_options(host: 'localhost', port: 6379, encoding: 'ASCII-8BIT')
+    r
+  end
+  
+    
+  let(:location_id) { (1..1000).to_a.sample }
+  let(:fake_data) { (0...8).map { (65 + rand(26)).chr }.join }
+  
+  it { should respond_to(:host) }
+  it { should respond_to(:port) }
+
+  
+  describe '#get' do
+    
+    it 'should fetch data from Redis' do
+      Redis.any_instance.should_receive(:get)
+      redis_storage.get(location_id)
+    end
+    
+    it 'should return data saved to a location' do
+      redis_storage.set(location_id, fake_data)
+      redis_storage.get(location_id).should eq fake_data
+    end
+
+    context 'encoding is configured' do
+      
+      it 'should use force encoding from configuration' do
+        redis_storage_encoding.set(location_id, fake_data)
+        redis_storage_encoding.get(location_id).encoding.name.should eq redis_storage_encoding.encoding
+      end
+      
+    end
+    
+  end
+  
+  describe '#exists?' do
+    
+    context 'key is present in Redis' do
+      
+      before(:each) { Redis.any_instance.stub(:exists).and_return(true) }
+      
+      it 'should return true' do
+        redis_storage.exists?(location_id).should be true
+      end
+      
+    end
+    
+    context 'key is not present in Redis' do
+      
+      before(:each) { Redis.any_instance.stub(:exists).and_return(false) }
+      
+      it 'should return false' do
+        redis_storage.exists?(location_id).should be false
+      end
+      
+    end
+
+  end
+  
+  describe '#set' do
+    
+    it 'should persit the data to Redis' do
+      Redis.any_instance.should_receive(:set)
+      redis_storage.set(location_id, fake_data)
+    end
+    
+    it 'should return true if save was successful' do
+      redis_storage.set(location_id, fake_data).should be true
+    end
+    
+    it 'should set expiry time if option present' do
+      Redis.any_instance.should_receive(:expire)
+      redis_storage_expiry.set(location_id, fake_data)
+    end
+    
+    it 'should not set expiry time if expiry option is not present' do
+      Redis.any_instance.should_not_receive(:expire)
+      redis_storage.set(location_id, fake_data)
+    end
+    
+    
+  end
+  
+  
+  describe '#connect' do
+    
+    it 'should raise an error unless host and port are present' do
+      r = Quandl::Location::Storage::Redis.new
+      expect { r.connect }.to raise_error
+      r.host = 'test'
+      expect { r.connect }.to raise_error
+      r.host = nil
+      r.port = 'test'
+      expect { r.connect }.to raise_error
+      r.host = 'test'
+      expect { r.connect }.not_to raise_error
+    end
+    
+
+  end
+  
+end

data/spec/quandl/location/storage_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Quandl::Location::Storage do
+  
+  let(:storage) { Quandl::Location::Storage.new }
+  
+  describe '#get' do
+ 
+    it 'should raise exception for incomplete implementation' do
+      expect { storage.get }.to raise_error
+    end
+ 
+  end
+  
+  describe '#exists?' do
+    
+    it 'should raiser for incomplete implentation' do
+      expect { storage.exists? }.to raise_error
+    end
+        
+  end
+  
+  describe '#set' do
+ 
+    it 'should raise exception for incomplete implementation' do
+      expect { storage.set }.to raise_error
+    end
+ 
+  end
+  
+  describe '#with_options' do
+    
+    context 'storage options not provided' do
+      
+      it 'should raise exception' do
+        expect { storage.with_options }.to raise_error
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/quandl/location_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Quandl::Location do
+  
+  before(:each) do
+    # Clear class variables between tests
+    Quandl::Location.class_variable_set(:@@storage_engine, nil)
+    Quandl::Location.class_variable_set(:@@storage_engine_type, nil)
+  end
+  
+  let(:valid_storage_engine) { Quandl::Location::storage_engines.sample }
+  
+  describe '#storage_engines' do
+    
+    it 'should return the supported storage engines' do
+      Quandl::Location.storage_engines.should be Quandl::Location::STORAGE_ENGINES
+    end
+    
+  end
+  
+  describe '#use' do
+    
+    it 'it should raise an error for unsupported storage engines' do
+      expect { Quandl::Location.use(:quandl_fake_storage) }.to raise_error
+    end
+    
+    it 'should allow supported storage engines' do
+      Quandl::Location.storage_engines.each do |engine|
+        expect { Quandl::Location.use(engine) }.not_to raise_error
+      end
+    end
+    
+    it 'should send provided block as configuration to Storage instance' do
+      Quandl::Location::Storage.any_instance.should_receive(:my_configuration_function)
+      Quandl::Location.use(valid_storage_engine) { my_configuration_function }
+    end
+    
+  end
+  
+  describe '#storage_engine' do
+    
+    context 'a storage engine has been initialized' do
+      
+      it 'should raise an error' do
+        expect { Quandl::Location.storage_engine }.to raise_error
+      end
+  
+    end
+    
+    context 'a storage engine has not been initialized' do
+      
+      it 'should not raise an error' do
+        Quandl::Location.use(valid_storage_engine)
+        expect { Quandl::Location.storage_engine }.not_to raise_error
+      end
+      
+    end
+    
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + "../lib")
+
+# Testing
+require 'rspec'
+require 'fakeredis/rspec'
+
+# Application
+require 'quandl/location'
+
+# Configure RSpec
+RSpec.configure do |config|
+  
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.formatter = :documentation  
+  config.tty = true
+  config.color_enabled = true
+  
+end

data/spec/support/config/file_storage.yml

@@ -0,0 +1,2 @@
+test:
+  data_dir: '/data/dir'

data/spec/support/config/redis.yml

@@ -0,0 +1,4 @@
+test:
+  host: 127.0.0.1
+  port: 5959
+  

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: quandl_location
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Jason Byck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3'
+description: Provides a library for accessing data from arbitrary key-value storage
+email:
+- jasonbyck@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/quandl/location.rb
+- lib/quandl/location/data.rb
+- lib/quandl/location/exceptions.rb
+- lib/quandl/location/storage.rb
+- lib/quandl/location/storage/file_system.rb
+- lib/quandl/location/storage/redis.rb
+- lib/quandl/location/version.rb
+- quandl_location.gemspec
+- spec/quandl/location/data_spec.rb
+- spec/quandl/location/storage/file_system_spec.rb
+- spec/quandl/location/storage/redis_spec.rb
+- spec/quandl/location/storage_spec.rb
+- spec/quandl/location_spec.rb
+- spec/quandl/support/fake_redis.rb
+- spec/spec_helper.rb
+- spec/support/config/file_storage.yml
+- spec/support/config/redis.yml
+homepage: https://github.com/quandl/quandl_location
+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: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Abstracted key value storage library
+test_files:
+- spec/quandl/location/data_spec.rb
+- spec/quandl/location/storage/file_system_spec.rb
+- spec/quandl/location/storage/redis_spec.rb
+- spec/quandl/location/storage_spec.rb
+- spec/quandl/location_spec.rb
+- spec/quandl/support/fake_redis.rb
+- spec/spec_helper.rb
+- spec/support/config/file_storage.yml
+- spec/support/config/redis.yml