skeevy 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60dbb058fbd64464e26b03c882c45c4b2db40de1
+  data.tar.gz: 5590acba53788fcb6bff72a29541748c839138d4
+SHA512:
+  metadata.gz: f664d159edf898beb72fb627f2f7d4b4d094137fb2092ebbe6546111b73418ec524fd818b4732b6cfff412a113af8b2b7ccc5be30058d59c98c8e99da49ce6c0
+  data.tar.gz: fdfc302598f411e23c598f63b96deaa9563ba2683d030ff8fd92cb8a752cd801efac25351a49664df52ccc5988f9f1e4550085df696ffa2af1b450ac5a011ccd

data/.gitignore

@@ -0,0 +1,34 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+.*.sw[a-z]
+
+## RubyMine and related
+.idea
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+tmp/*
+*.rbc
+*.rbx
+.ruby-gemset
+.ruby-version
+

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/Guardfile

@@ -0,0 +1,46 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %(app lib config test spec feature)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "ostruct"
+
+  # Generic Ruby apps
+  rspec = OpenStruct.new
+  rspec.spec = ->(m) { "spec/#{m}_spec.rb" }
+  rspec.spec_dir = "spec"
+  rspec.spec_helper = "spec/spec_helper.rb"
+
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$}) { |m|
+    rspec.spec.("lib/#{m[1]}")
+  }
+  watch(%r{^lib/skeevy/(.+)\.rb$}) { |m|
+    rspec.spec.("lib/skeevy/#{m[1]}")
+    rspec.spec.("lib/skeevy")
+  }
+  watch(%r{^lib/skeevy/cutters/(.+)\.rb$}) { |m|
+    rspec.spec.("lib/skeevy/cutters/#{m[1]}")
+    rspec.spec.("lib/skeevy")
+  }
+  watch(%r{^lib/skeevy/engines/(.+)\.rb$}) { |m|
+    rspec.spec.("lib/engines/#{m[1]}")
+    rspec.spec.("lib/skeevy")
+  }
+  watch(rspec.spec_helper)      { rspec.spec_dir }
+
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Craig Waterman
+
+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,21 @@
+Skeevy
+==============
+
+Simple Key Value abstractions, supporting pluggable storage engines.
+
+Requirements
+-----------------
+
+Skeevy requires Ruby 2.1 for required named parameters. Rubinius 2.4+, JRuby
+9000+ and MRI 2.1+ seem functional.
+
+Installation
+-----------------
+
+    gem install skeevy
+
+
+Getting Started
+-----------------
+
+Start coding.

data/lib/skeevy.rb

@@ -0,0 +1,37 @@
+require 'skeevy/version'
+require 'skeevy/engine'
+require 'skeevy/cutter'
+require 'skeevy/cutters/standard_key'
+require 'skeevy/engines/symbolic_hash'
+require 'skeevy/engines/directory_file'
+require 'skeevy/instance'
+
+fail "Skeevy #{Skeevy::VERSION} requires Ruby 2.1 or later." if RUBY_VERSION < '2.1.0'
+
+module Skeevy
+
+  # Poor-man's singleton
+  class << self
+    def register!(identifier:, engine: nil, cutter: nil)
+      raise(ArgumentError, "Identifier must be a symbol") unless identifier.is_a?(Symbol)
+      @instances ||= {}
+      @instances[identifier] = Instance.new identifier: identifier,
+                                       engine: engine,
+                                       cutter: cutter
+    end
+
+    def instance(identifier)
+      raise(ArgumentError, "Identifier must be a symbol") unless identifier.is_a?(Symbol)
+      @instances[identifier]
+    end
+
+    def [](identifier)
+      instance(identifier)
+    end
+
+    def inspect
+      "Skeevy #{Skeevy::VERSION}"
+    end
+  end
+
+end

data/lib/skeevy/cutter.rb

@@ -0,0 +1,22 @@
+module Skeevy
+  module Cutter
+
+    attr_accessor :instance
+    attr_reader :delimiter
+    attr_reader :prefix
+
+    def initialize(instance: nil, delimiter: '-', prefix: nil)
+      raise(ArgumentError, "Unable to init Skeevy Cutters without a delimiter") if delimiter.nil?
+      raise ArgumentError,
+            "Instance passed was not a Skeevy::Instance" unless
+          instance.is_a?(Skeevy::Instance) || instance.nil?
+      @instance  = instance
+      @delimiter = delimiter
+      @prefix    = prefix
+    end
+
+    def cut(hash:, ns:, object: nil)
+      raise NoMethodError, "Your Cutter is invalid."
+    end
+  end
+end

data/lib/skeevy/cutters/standard_key.rb

@@ -0,0 +1,20 @@
+module Skeevy
+  module Cutters
+    class StandardKey
+      include Skeevy::Cutter
+
+      def cut(hash:, ns:, object: nil)
+        object ||= ''
+        hash   ||= ''
+        ns     ||= ''
+        raise ArgumentError, "Hash and namespace may not be blank" if hash.empty? || ns.empty?
+        raise ArgumentError, "#{object} contains an instance of delimiter: #{@delimiter}" if object.include?(@delimiter)
+        prefix ="#{@prefix}#{@delimiter}" unless @prefix.nil?
+        key = "#{ns}#{@delimiter}#{hash}"
+        suffix = "#{@delimiter}#{object}" unless object == ''
+        "#{prefix}#{key}#{suffix}"
+      end
+
+    end
+  end
+end

data/lib/skeevy/engine.rb

@@ -0,0 +1,22 @@
+module Skeevy
+  module Engine
+
+    attr_accessor :instance
+
+    def read(key:)
+      raise NoMethodError, "Your Engine is missing .read"
+    end
+
+    def write!(key:, content:)
+      raise NoMethodError, "Your Engine is missing .write!"
+    end
+
+    def exist?(key:)
+      raise NoMethodError, "Your Engine is missing .exist?"
+    end
+
+    def delete!(key:)
+      raise NoMethodError, "Your Engine is missing .delete!"
+    end
+  end
+end

data/lib/skeevy/engines/directory_file.rb

@@ -0,0 +1,74 @@
+module Skeevy
+  module Engines
+    class DirectoryFile
+      include Skeevy::Engine
+      require 'fileutils'
+
+      def initialize(instance:, base_dir:, delimiter:, encoding: 'UTF-8')
+        raise ArgumentError,
+              "Instance passed was not a Skeevy::Instance" unless
+            instance.is_a?(Skeevy::Instance) || instance.nil?
+        @base_dir     = base_dir
+        @encoding     = encoding
+        @instance     = instance
+        @delimiter    = delimiter
+        @exists_cache = {}
+        ensure_base_dir_exists
+      end
+
+      def path_for(key:)
+        directory = key.split(@delimiter)
+        filename  = directory.pop # naive
+        path      = File.join(@base_dir, directory)
+        ensure_exists(path: path)
+        File.join(path, filename)
+      end
+
+      def exist?(key:, path: nil)
+        if path.nil?
+          File.exist? path_for(key: key)
+        else
+          File.exist? path
+        end
+      end
+
+      def read(key:)
+        path = path_for(key: key)
+        if exist?(path: path, key: nil)
+          File.open(path, "r:#{@encoding}") { |f|
+            f.read
+          }
+        else
+          nil
+        end
+      end
+
+      def write!(key:, content:)
+        path = path_for(key: key)
+        File.open(path, "w:#{@encoding}") { |f|
+          f.write content
+        }
+      end
+
+      def delete!(key:)
+        path = path_for(key: key)
+        if exist?(path: path, key: nil)
+          File.unlink(path)
+          return true
+        end
+        false
+      end
+
+      private
+
+      def ensure_exists(path:)
+        FileUtils.mkdir_p(path) if @exists_cache[path].nil?
+        @exists_cache[path] = true
+      end
+
+      def ensure_base_dir_exists
+        ensure_exists(path: @base_dir)
+      end
+    end
+  end
+end

data/lib/skeevy/engines/symbolic_hash.rb

@@ -0,0 +1,37 @@
+module Skeevy
+  module Engines
+    class SymbolicHash
+      include Skeevy::Engine
+
+      def initialize(instance:)
+        raise ArgumentError,
+              "Instance passed was not a Skeevy::Instance" unless
+              instance.is_a?(Skeevy::Instance) || instance.nil?
+        @instance = instance
+        @items = {}
+      end
+
+      def exist?(key:)
+        @items.has_key? key.to_sym
+      end
+
+      def read(key:)
+        @items[key.to_sym]
+      end
+
+      def write!(key:, content:)
+        @items[key.to_sym] = content
+      end
+
+      def delete!(key:)
+        k = key.to_sym
+        if @items.has_key?(k)
+          @items.delete k
+          return true
+        end
+        false
+      end
+
+    end
+  end
+end

data/lib/skeevy/instance.rb

@@ -0,0 +1,46 @@
+module Skeevy
+  class Instance
+
+    attr_reader :engine, :cutter
+
+    def initialize(identifier:,
+                   engine: nil,
+                   cutter: nil)
+      raise(ArgumentError, "identifier must be a Symbol") unless identifier.is_a?(Symbol)
+      raise(ArgumentError, "engine is not a Skeevy Engine!") unless @engine.is_a?(Skeevy::Engine) || engine.nil?
+      raise(ArgumentError, "cutter is not a Skeevy Cutter!") unless @cutter.is_a?(Skeevy::Cutter) || cutter.nil?
+      @cutter = cutter || Skeevy::Cutters::StandardKey.new(instance: self)
+      @engine = engine || Skeevy::Engines::SymbolicHash.new(instance: self)
+      @identifier = identifier
+    end
+
+    def object_key(hash:, ns:, object:)
+      @cutter.cut(hash: hash, ns: ns, object: object)
+    end
+
+    def container_key(hash:, ns:)
+      @cutter.cut(hash: hash, ns: ns, object: nil)
+    end
+
+    def read(key:)
+      @engine.read(key: key)
+    end
+
+    def write!(key:, content:)
+      @engine.write!(key: key, content: content)
+    end
+
+    def exist?(key:)
+      @engine.exist?(key: key)
+    end
+
+    def delete!(key:)
+      @engine.delete!(key: key)
+    end
+
+    def to_s
+      { identifier: @identifier, engine: @engine, cutter: @cutter}.to_s
+    end
+
+  end
+end

data/lib/skeevy/version.rb

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

data/skeevy.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name        = 'skeevy'
+  s.version     = '0.0.1'
+  s.date        = '2014-12-19'
+  s.summary     = "Skeevy"
+  s.description = "A simple key-value store for objects"
+  s.authors     = ["Craig Waterman"]
+  s.email       = 'craigwaterman@gmail.com'
+  s.homepage    =
+      'http://rubygems.org/gems/skeevy'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rspec',   '~> 3.1'
+  s.add_development_dependency 'guard-rspec', '~> 4.4.2'
+end

data/spec/lib/skeevy/cutters/standard_key_spec.rb

@@ -0,0 +1,18 @@
+RSpec.describe :standard_key do
+
+  let!(:the_cutter_class) { Skeevy::Cutters::StandardKey }
+  let!(:the_cutter) { Skeevy::Cutters::StandardKey.new }
+  include_examples "a skeevy cutter"
+
+  describe '#cut verification' do
+    it 'creates appropriate keys without object' do
+      expect(the_cutter.cut(hash: 'abc', ns: 'test')).to eq('test-abc')
+    end
+    it 'creates appropriate keys with object' do
+      expect(the_cutter.cut(hash: 'abc',
+                            ns: 'test',
+                            object: 'file.json')).to eq('test-abc-file.json')
+    end
+  end
+
+end

data/spec/lib/skeevy/engines/directory_file_spec.rb

@@ -0,0 +1,50 @@
+require 'fileutils'
+
+RSpec.describe :directory_file do
+
+  let!(:the_engine_class) { Skeevy::Engines::DirectoryFile }
+  let!(:the_engine) { the_engine_class.new(instance: nil, base_dir: 'tmp', delimiter: '-') }
+  let!(:write_key) { 'a-b-c-file.json' }
+  include_examples "a skeevy engine"
+
+  describe ".initialize verification" do
+    it 'rejects badly typed instances' do
+      expect {
+        the_engine_class.new(instance: :nope, base_dir: 'tmp', delimiter: '-')
+      }.to raise_error(ArgumentError, /was not a/)
+    end
+    it 'rejects missing keywords' do
+      expect {
+        the_engine_class.new(delimiter: '-')
+      }.to raise_error(ArgumentError, /missing keywords/)
+      expect {
+        the_engine_class.new(base_dir: 'tmp')
+      }.to raise_error(ArgumentError, /missing keywords/)
+    end
+  end
+
+  describe '#write! verification' do
+    it 'should create the appropriate directory' do
+      write_file
+      expect(File.directory?('tmp/a/b/c')).to be_truthy
+    end
+
+    it 'should create the appropriate file' do
+      write_file
+      expect(File.exist?('tmp/a/b/c/file.json')).to be_truthy
+    end
+  end
+
+  describe '#delete! verification' do
+    it 'should remove the file' do
+      write_file
+      the_engine.delete!(key: write_key)
+      expect(File.exist?('tmp/a/b/c/file.json')).to be_falsey
+    end
+  end
+
+  def write_file
+    the_engine.write!(key: write_key, content: '{}')
+  end
+
+end

data/spec/lib/skeevy/engines/symbolic_hash_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe :symbolic_hash do
+
+  let!(:the_engine_class) { Skeevy::Engines::SymbolicHash }
+  let!(:the_engine) { the_engine_class.new(instance: nil) }
+  include_examples "a skeevy engine"
+
+  describe ".initialize verification" do
+    it 'rejects badly typed instances' do
+      expect {
+        the_engine_class.new(instance: :nope)
+      }.to raise_error(ArgumentError, /was not a/)
+    end
+  end
+
+end

data/spec/lib/skeevy/instance_spec.rb

@@ -0,0 +1,49 @@
+RSpec.describe :instance do
+
+  let(:instance) { Skeevy::Instance.new(identifier: :test) }
+  let(:cutter) { instance.cutter }
+  let(:engine) { instance.engine }
+
+  describe '#object_key' do
+    it 'passes the function to @cutter' do
+      expect(cutter).to receive(:cut).with(hash: 'abc', ns: 'test', object: 'test')
+      instance.object_key(hash: 'abc', ns: 'test', object: 'test')
+    end
+  end
+
+  describe '#container_key' do
+    it 'passes the function to @cutter' do
+      expect(cutter).to receive(:cut).with(hash: 'abc', ns: 'test', object: nil)
+      instance.container_key(hash: 'abc', ns: 'test')
+    end
+  end
+
+  describe '#read' do
+    it 'passes the function to @engine' do
+      expect(engine).to receive(:read).with(key: 'abc')
+      instance.read(key: 'abc')
+    end
+  end
+
+  describe '#write!' do
+    it 'passes the function to @engine' do
+      expect(engine).to receive(:write!).with(key: 'abc', content: 'testing')
+      instance.write!(key: 'abc', content: 'testing')
+    end
+  end
+
+  describe '#exist?' do
+    it 'passes the function to @engine' do
+      expect(engine).to receive(:exist?).with(key: 'abc')
+      instance.exist?(key: 'abc')
+    end
+  end
+
+  describe '#delete!' do
+    it 'passes the function to @engine' do
+      expect(engine).to receive(:delete!).with(key: 'abc')
+      instance.delete!(key: 'abc')
+    end
+  end
+
+end

data/spec/lib/skeevy/version_spec.rb

@@ -0,0 +1,2 @@
+RSpec.describe :version do
+end

data/spec/lib/skeevy_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe :skeevy do
+
+  let!(:default_instance) { Skeevy.register!(identifier: :default) }
+
+  describe '.register!' do
+    it 'requires an identifier' do
+      expect { Skeevy.register! }.to raise_error(ArgumentError, /identifier/)
+    end
+
+    it 'validates engine type' do
+      expect {
+        Skeevy.register!(identifier: :test, engine: "My Engine")
+      }.to raise_error(ArgumentError, /Engine!/)
+    end
+
+    it 'validates cutter type' do
+      expect {
+        Skeevy.register!(identifier: :test, cutter: "My Cutter")
+      }.to raise_error(ArgumentError, /Cutter!/)
+    end
+
+  end
+
+  describe 'default instantiation' do
+
+    it 'creates a default instance with only an identifier' do
+      expect(default_instance).to be_instance_of(Skeevy::Instance)
+    end
+
+    it 'has a StandardKey cutter' do
+      expect(default_instance.cutter).to be_instance_of(Skeevy::Cutters::StandardKey)
+    end
+
+    it 'has a SymbolicHash engine' do
+      expect(default_instance.engine).to be_instance_of(Skeevy::Engines::SymbolicHash)
+    end
+
+    it 'makes the default Skeeve available via .instance' do
+      my_instance = Skeevy.instance(:default)
+      expect(my_instance).to equal(default_instance)
+    end
+
+    it 'ensures [] is equivalent to .instance' do
+      expect(Skeevy.instance(:default)).to equal(Skeevy[:default])
+    end
+
+  end
+
+  describe '.inspect' do
+    it 'outputs the proper string' do
+      expect(Skeevy.inspect).to eq "Skeevy #{Skeevy::VERSION}"
+    end
+  end
+
+end

data/spec/shared/cutter.rb

@@ -0,0 +1,58 @@
+require 'set'
+
+RSpec.shared_examples 'a skeevy cutter' do
+
+  describe '.initialize accepts only proper instances' do
+    it 'allows nil instances' do
+      expect(the_cutter).to be_a_kind_of(Skeevy::Cutter)
+    end
+    it 'rejects badly typed instances' do
+      expect {
+        the_cutter_class.new(instance: :nope)
+      }.to raise_error(ArgumentError, /was not a/)
+    end
+    it 'rejects missing delimiter' do
+      expect {
+        the_cutter_class.new(delimiter: nil)
+      }.to raise_error(ArgumentError, /without a/)
+    end
+  end
+
+  describe '#cut' do
+    it 'rejects missing keywords' do
+      expect {
+        the_cutter.cut(hash: '')
+      }.to raise_error(ArgumentError, /missing keyword/)
+      expect {
+        the_cutter.cut(ns: '')
+      }.to raise_error(ArgumentError, /missing keyword/)
+    end
+    it 'returns a string' do
+      expect(the_cutter.cut(hash: 'abc', ns: 'test')).to be_instance_of(String)
+      expect(the_cutter.cut(hash: 'abc', ns: 'test', object: 'file.json')).to be_instance_of(String)
+    end
+    it 'rejects empty hashes' do
+      expect {
+        the_cutter.cut(hash: '', ns: 'test')
+      }.to raise_error(ArgumentError, /not be blank/)
+      expect {
+        the_cutter.cut(hash: nil, ns: 'test')
+      }.to raise_error(ArgumentError, /not be blank/)
+    end
+    it 'rejects empty namespaces' do
+      expect {
+        the_cutter.cut(hash: 'abc', ns: '')
+      }.to raise_error(ArgumentError, /not be blank/)
+      expect {
+        the_cutter.cut(hash: 'abc', ns: nil)
+      }.to raise_error(ArgumentError, /not be blank/)
+    end
+    it 'rejects object names containing the class delimiter' do
+      expect {
+        the_cutter.cut(hash: 'abc', ns: 'test', object: 'bad-object-name.json')
+      }.to raise_error(ArgumentError, /of delimiter/)
+    end
+
+  end
+
+end

data/spec/shared/engine.rb

@@ -0,0 +1,57 @@
+require 'set'
+
+RSpec.shared_examples 'a skeevy engine' do
+
+  describe '.initialize accepts only proper instances' do
+    it 'should allow nil instances' do
+      expect(the_engine).to be_a_kind_of(Skeevy::Engine)
+    end
+    it 'should reject badly typed instances' do
+      expect {
+        Skeevy::Engines::SymbolicHash.new(instance: :nope)
+      }.to raise_error(ArgumentError, /was not a/)
+    end
+  end
+
+  describe '#exist?' do
+    k = 'exist_test-file.json'
+    it 'properly identifies missing items' do
+      expect(the_engine.exist?(key: k)).to be_falsey
+    end
+    it 'properly identifies existing items' do
+      the_engine.write!(key: k, content: 'xyz')
+      expect(the_engine.exist?(key: k)).to be_truthy
+    end
+  end
+
+  describe '#write!' do
+    it 'writes to a key' do
+      k = 'write_test-file.json'
+      v = '{}'
+      the_engine.write!(key: k, content: v)
+      expect(the_engine.exist?(key: k)).to be_truthy
+    end
+  end
+
+  describe '#read' do
+    it 'returns proper results from a hash' do
+      k = 'read_test-file.json'
+      v = '{}'
+      the_engine.write!(key: k, content: v)
+      expect(the_engine.read(key: k)).to eq(v)
+    end
+    it 'returns nil when a key does not exist' do
+      expect(the_engine.read(key: 'missing_key_test')).to eq(nil)
+    end
+  end
+
+  describe '#delete!' do
+    it 'removes keys that exist' do
+      k = 'delete_test-file.json'
+      the_engine.write!(key: k, content: '{}')
+      expect(the_engine.delete!(key: k)).to equal(true)
+      expect(the_engine.exist?(key: k)).to be_falsey
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'skeevy'
+require 'shared/engine'
+require 'shared/cutter'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.after(:all) do
+    FileUtils.rm_rf(Dir["tmp/[^.]*"])
+  end
+
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: skeevy
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Craig Waterman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-12-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.4.2
+description: A simple key-value store for objects
+email: craigwaterman@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- lib/skeevy.rb
+- lib/skeevy/cutter.rb
+- lib/skeevy/cutters/standard_key.rb
+- lib/skeevy/engine.rb
+- lib/skeevy/engines/directory_file.rb
+- lib/skeevy/engines/symbolic_hash.rb
+- lib/skeevy/instance.rb
+- lib/skeevy/version.rb
+- skeevy.gemspec
+- spec/lib/skeevy/cutters/standard_key_spec.rb
+- spec/lib/skeevy/engines/directory_file_spec.rb
+- spec/lib/skeevy/engines/symbolic_hash_spec.rb
+- spec/lib/skeevy/instance_spec.rb
+- spec/lib/skeevy/version_spec.rb
+- spec/lib/skeevy_spec.rb
+- spec/shared/cutter.rb
+- spec/shared/engine.rb
+- spec/spec_helper.rb
+homepage: http://rubygems.org/gems/skeevy
+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.4.3
+signing_key: 
+specification_version: 4
+summary: Skeevy
+test_files:
+- spec/lib/skeevy/cutters/standard_key_spec.rb
+- spec/lib/skeevy/engines/directory_file_spec.rb
+- spec/lib/skeevy/engines/symbolic_hash_spec.rb
+- spec/lib/skeevy/instance_spec.rb
+- spec/lib/skeevy/version_spec.rb
+- spec/lib/skeevy_spec.rb
+- spec/shared/cutter.rb
+- spec/shared/engine.rb
+- spec/spec_helper.rb