rffdb 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc32e7e6da39ca78200a564f07ababf89cb3749f
+  data.tar.gz: a9978b86ec538b44b238e10e32fa85bb4bc83136
+SHA512:
+  metadata.gz: 8220e8ef033aa49a605148edf591334d6449e569ca38a3a823b2b6019759d077e390a3be3e1d6e5c718b22e79eeecf9a3c0b42443fb057c16748f40978b2fd22
+  data.tar.gz: 84ccd13638927c947da052720ffda3fcd50869a0a267308f5c9a6e466deebbb8a908929b31bba261a839f60b1bdd9048878f981b7d19e360dc0cd888b7409dfb

data/LICENSE

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

data/lib/rffdb/cache_provider.rb

@@ -0,0 +1,14 @@
+module RubyFFDB
+  # Generic Cache Provider definition. Any subclass *must* implement or inherit the methods defined here (if any).
+  class CacheProvider
+    # Used for pulling data from the cache
+    def [](key)
+      nil
+    end
+    
+    # Used for storing data in the cache
+    def []=(key, value)
+      false
+    end
+  end
+end

data/lib/rffdb/cache_providers/lru_cache.rb

@@ -0,0 +1,162 @@
+module RubyFFDB
+  module CacheProviders
+    # A very simple Least Recently Used (LRU) cache implementation. Stores data in a Hash,
+    # uses a dedicated Array for storing and sorting keys (and implementing the LRU algorithm),
+    # and doesn't bother storing access information for cache data. It stores hit and miss counts
+    # for the entire cache (not for individual keys). It also uses three mutexes for thread-safety:
+    # a write lock, a read lock, and a metadata lock.
+    class LRUCache < CacheProvider
+      attr_reader :max_size, :keys
+
+      # @raise [Exceptions::InvalidCacheSize] if the max_size isn't an Integer
+      def initialize(max_size = 100)
+        raise Exceptions::InvalidCacheSize unless max_size.kind_of?(Integer)
+
+        @max_size     = max_size
+        @hits         = 0
+        @misses       = 0
+        @keys         = []
+        @data         = {}
+        @read_mutex   = Mutex.new
+        @write_mutex  = Mutex.new
+        @meta_mutex   = Mutex.new
+      end
+
+      # Does the cache contain the requested item?
+      # @param key [Symbol] the index of the potentially cached object
+      def has?(key)
+        @meta_mutex.synchronize { @keys.include?(key) }
+      end
+
+      alias_method :has_key?, :has?
+      alias_method :include?, :has?
+
+      # The number of items in the cache
+      # @return [Fixnum] key count
+      def size
+        @meta_mutex.synchronize { @keys.size }
+      end
+
+      # Convert the contents of the cache to a Hash
+      # @return [Hash] the cached data
+      def to_hash
+        @read_mutex.synchronize { @data.dup }
+      end
+
+      # Return a raw Array of the cache data without its keys.
+      # Not particularly useful but it may be useful in the future.
+      # @return [Array] just the cached values
+      def values
+        @read_mutex.synchronize { @data.values }
+      end
+
+      # Allow iterating over the cached items, represented as key+value pairs
+      def each(&block)
+        to_hash.each(&block)
+      end
+
+      # Invalidate a cached item by its index / key. Returns `nil` if the object doesn't exist.
+      # @param key [Symbol] the cached object's index
+      def invalidate(key)
+        invalidate_key(key)
+        @write_mutex.synchronize { @data.delete(key) }
+      end
+
+      alias_method :delete, :invalidate
+
+      # Remove all items from the cache without clearing statistics
+      # @return [Boolean] was the truncate operation successful?
+      def truncate
+        @read_mutex.synchronize do
+          @write_mutex.synchronize do
+            @meta_mutex.synchronize { @keys   = [] }
+            @data   = {}
+          end
+          @data.empty?
+        end
+      end
+
+      # Similar to {#truncate} (in fact, it calls it) but it also clears the statistical metadata.
+      # @return [Boolean] was the flush operation successful?
+      def flush
+        if truncate
+          @meta_mutex.synchronize { @hits, @misses = 0, 0 }
+          true
+        else
+          false
+        end
+      end
+
+      # Provides a hash of the current metadata for the cache. It provides the current cache size (`:size`),
+      # the number of cache hits (`:hits`), and the number of cache misses (`:misses`).
+      # @return [Hash] cache statistics
+      def statistics
+        {size: size, hits: @meta_mutex.synchronize { @hits }, misses: @meta_mutex.synchronize { @misses }}
+      end
+
+      # Store some data (`value`) indexed by a `key`. If an object exists with the same key, and the
+      # value is different, it will be overwritten. Storing a value causes its key to be moved to the end
+      # of the keys array (meaning it is the __most recently used__ item), and this happens on #store regardless
+      # of whether or not the key previously existed. This behavior is relied upon by {#retrieve} to allow
+      # reorganization of the keys without necessarily modifying the data it indexes. Uses recursion for overwriting
+      # existing items.
+      #
+      # @param key [Symbol] the index to use for referencing this cached item
+      # @param value [Object] the data to cache
+      def store(key, value)
+        if has?(key)
+          if @read_mutex.synchronize { @data[key] == value }
+            invalidate_key(key)
+            @meta_mutex.synchronize { @keys << key }
+            value
+          else
+            invalidate(key)
+            store(key, value)
+          end
+        else
+          if size >= @max_size
+            invalidate(@keys.first) until size < @max_size
+          end
+
+          @write_mutex.synchronize do
+            @meta_mutex.synchronize { @keys << key }
+            @data[key] = value
+          end
+        end
+      end
+
+      alias_method :[]=, :store
+
+      # Retrieve an item from the cache. Returns `nil` if the item doesn't exist. Relies on {#store} returning the
+      # stored value to ensure the LRU algorithm is maintained safely.
+      # @param key [Symbol] the index to retrieve
+      def retrieve(key)
+        if has?(key)
+          @meta_mutex.synchronize { @hits += 1 }
+          # Looks dumb, as it stores the value again, but it actually only reorganizes the keys Array
+          store(key, @read_mutex.synchronize { @data[key] })
+        else
+          @meta_mutex.synchronize { @misses += 1 }
+          nil
+        end
+      end
+
+      alias_method :[], :retrieve
+
+      def marshal_dump
+        [@max_size, @hits, @misses, @keys, @data]
+      end
+
+      def marshal_load(array)
+        @max_size, @hits, @misses, @keys, @data = array
+      end
+
+      private
+
+      # Invalidate just the key of a cached item. Dangerous if used incorrectly.
+      def invalidate_key(key)
+        @meta_mutex.synchronize { @keys.delete(key) }
+      end
+    end
+  end
+end

data/lib/rffdb/cache_providers/rr_cache.rb

@@ -0,0 +1,35 @@
+module RubyFFDB
+  module CacheProviders
+    # A simple Random Replacement (RR) cache implementation. Stores data in a Hash,
+    # uses a dedicated Array for storing keys (and implementing the RR algorithm),
+    # and doesn't bother storing access information for cache data. It stores hit and miss counts
+    # for the entire cache (not for individual keys). It also uses three mutexes for thread-safety:
+    # a write lock, a read lock, and a metadata lock. The RRCache borrows nearly all its functionality
+    # from the {LRUCache}, only overwriting the storage (and therefore the revocation) method.
+    class RRCache < LRUCache
+      # Store some data (`value`) indexed by a `key`. If an object exists with the same key, and the
+      # value is different, it will be overwritten. Storing a new item when the cache is full causes
+      # the keys Array a random entry to be evicted via a shuffling of the keys. Keys are stored in
+      # the order in which they were inserted (not shuffled).
+      #
+      # @param key [Symbol] the index to use for referencing this cached item
+      # @param value [Object] the data to cache
+      def store(key, value)
+        if has?(key)
+          super(key, value)
+        else
+          if size >= @max_size
+            invalidate(@keys.shuffle.first) until size < @max_size
+          end
+
+          @write_mutex.synchronize do
+            @meta_mutex.synchronize { @keys << key }
+            @data[key] = value
+          end
+        end
+      end
+
+      alias_method :[]=, :store
+    end
+  end
+end

data/lib/rffdb/document.rb

@@ -0,0 +1,225 @@
+module RubyFFDB
+  class Document
+
+    # @raise [Exceptions::NoSuchDocument] when attempting to retrieve a non-existing document by id
+    def initialize(existing_id = false, lazy = true)
+      if existing_id
+        @document_id  = existing_id
+        raise Exceptions::NoSuchDocument unless File.exists?(file_path)
+        if lazy
+          @lazy = true
+        else
+          reload(true)
+          @lazy = false
+        end
+        @saved = true
+      else
+        @document_id = storage.next_id(self.class)
+        @data = {}
+        # relative to database root
+        @saved = false
+      end
+      @read_lock  = Mutex.new
+      @write_lock = Mutex.new
+    end
+
+    # Overrides the Object#id method to deliver an id derived from this document's storage engine
+    # @return [Fixnum] the object id from the storage engine
+    def id
+      @document_id
+    end
+
+    # The location of the flat-file
+    # @return [String] the path to the flat-file used to store this document (may not exist yet)
+    def file_path
+      storage.file_path(self.class, @document_id)
+    end
+
+    # Commit the document to storage
+    # @return [Boolean]
+    def commit
+      @read_lock.synchronize do
+        @write_lock.synchronize do
+          storage.store(self.class, @document_id, @data.dup) unless @saved
+          @saved = true
+        end
+      end
+    end
+
+    alias_method :save, :commit
+
+    # Has this documented been committed to storage?
+    # @return [Boolean]
+    def committed?
+      return @saved
+    end
+
+    # Retrieve the stored data from disk, never using cache. Allows forcing to overwrite uncommitted changes.
+    # @raise [Exceptions::PendingChanges] if attempting to reload with uncommitted changes (and if `force` is false)
+    def reload(force = false)
+      if committed? or force
+        @read_lock.synchronize do
+          @write_lock.synchronize do
+            @data = storage.retrieve(self.class, @document_id, false)
+          end
+        end
+      else
+        raise Exceptions::PendingChanges
+      end
+      @read_lock.synchronize do
+        @write_lock.synchronize { @saved = true }
+      end
+    end
+
+    # Overwrites the document's data, either from disk or from cache. Useful for lazy-loading and not
+    # typically used directly. Since data might have been pulled from cache, this can lead to bizarre
+    # things if not used carefully and things rely on #committed? or @saved.
+    def refresh
+      @write_lock.synchronize do
+        @data = storage.retrieve(self.class, @document_id)
+        @saved = true
+      end
+    end
+
+    # Currently an alias for #new, but used as a wrapper in case more work needs to be done
+    # before pulling a document from the storage engine (such as sanitizing input, etc)
+    def self.load(id)
+      return self.new(id)
+    end
+
+    self.singleton_class.send(:alias_method, :get, :load)
+
+    # This DSL method is used to define the schema for a document. It sets up all data access for the class,
+    # and allows specifying strict checks on that schema during its use, such as validations, class types, regexp
+    # formatting, etc.
+    #
+    # @param name [Symbol] the unique name of the attribute
+    # @option options [Class] :class (Object) the expected object class for this attribute
+    # @option options [Regexp] :format a regular expression for the required format of the attribute (for any :class that supports #.to_s)
+    # @option options [Array, Symbol] :validate either a symbol or array of symbols referencing the instance method(s) to use to validate this attribute
+    def self.attribute(name, options = {})
+      @structure ||= {}
+      @structure[name.to_sym] = {}
+      # setup the schema
+      @structure[name.to_sym][:class]   = options.has_key?(:class) ? options[:class] : Object
+      @structure[name.to_sym][:format]  = options.has_key?(:format) ? options[:format] : nil
+      @structure[name.to_sym][:validations] = options.has_key?(:validate) ? [*options[:validate]] : []
+    end
+
+    # This DSL method is used to setup the backend {StorageEngine} class and optionally the {CacheProvider}
+    # for this Document type.
+    #
+    # @param storage_engine [Class] the {StorageEngine} child class to use
+    # @option cache_opts [Class] :cache_provider (CacheProviders::LRUCache) the {CacheProvider} child class for caching
+    # @option cache_opts [Fixnum] :cache_size the cache size, in terms of the number of objects stored
+    # @raise [Exceptions::InvalidEngine] if the specified {StorageEngine} does not exist
+    # @raise [Exceptions::InvalidCacheProvider] if a cache_provider is specified and it isn't a type of {CacheProvider}
+    def self.engine(storage_engine, cache_opts = {})
+      raise Exceptions::InvalidEngine unless storage_engine.instance_of? Class and storage_engine.ancestors.include?(StorageEngine)
+      @engine = storage_engine
+      if cache_opts.has_key?(:cache_provider)
+        # Make sure the cache provider specified is valid
+        unless cache_opts[:cache_provider].instance_of? Class and cache_opts[:cache_provider].ancestors.include?(CacheProvider)
+          raise Exceptions::InvalidCacheProvider
+        end
+        @engine.cache_provider(self, cache_opts[:cache_provider])
+      end
+      if cache_opts.has_key?(:cache_size)
+        @engine.cache_size(self, cache_opts[:cache_size])
+      end
+    end
+
+    # @return [StorageEngine] a reference to the storage engine singleton of this document class
+    def self.storage
+      @engine ||= StorageEngines::YamlEngine
+      @engine
+    end
+
+    # @return [StorageEngine] a reference to the storage engine singleton of this document class
+    def storage
+      self.class.send(:storage)
+    end
+
+    # @return [Hash] a copy of the schema information for this class
+    def self.structure
+      @structure ||= {}
+      @structure.dup
+    end
+
+    # @return [Hash] a copy of the schema information for this class
+    def structure
+      self.class.send(:structure)
+    end
+
+    # Sets the maximum number of entries the cache instance for this document will hold.
+    # Note, this clears the current contents of the cache.
+    # @param size [Fixnum] the maximum size of this class' cache instance
+    def self.cache_size(size)
+      storage.cache_size(self, size)
+    end
+
+    # Allow direct access to the cache instance of this document class
+    # @return [CacheProvider] this class' cache instance
+    def self.cache
+      storage.cache(self)
+    end
+
+    # Return all available instances of this type
+    # @return [DocumentCollection] all documents of this type
+    def self.all
+      DocumentCollection.new(storage.all(self).collect {|doc_id| load(doc_id)}, self)
+    end
+
+    # Query for Documents based on an attribute
+    # @see DocumentCollection#where
+    def self.where(attribute, value, comparison_method = "==")
+      all.where(attribute, value, comparison_method)
+    end
+
+    # Uses the defined schema to setup getter and setter methods. Runs validations,
+    # format checking, and type checking on setting methods.
+    # @raise [Exceptions::FailedValidation] if validation of an attribute fails while setting
+    # @raise [Exceptions::InvalidInput] if, while setting, an attribute fails to conform to the type or format defined in the schema
+    def method_missing(method, *args, &block)
+      setter  = method.to_s.match(/.*=$/) ? true : false
+      key     = setter ? method.to_s.match(/(.*)=$/)[1].to_sym : method.to_s.to_sym
+      
+      if structure.has_key?(key) and setter
+        if args.last.kind_of? structure[key][:class] and (structure[key][:format].nil? or args.last.to_s.match structure[key][:format])
+          valid = true
+          structure[key][:validations].each do |validation|
+            valid = self.send(validation.to_sym, args.last)
+            raise Exceptions::FailedValidation unless valid
+          end
+          refresh if @read_lock.synchronize { @lazy } and @read_lock.synchronize { committed? } # here is where the lazy-loading happens
+          @read_lock.synchronize do
+            @write_lock.synchronize do
+              @data[key.to_s] = args.last if valid
+            end
+          end
+        else
+          raise Exceptions::InvalidInput
+        end
+        @saved = false
+      elsif structure.has_key?(key)
+        refresh if @read_lock.synchronize { @lazy } and @read_lock.synchronize { committed? } # here is where the lazy-loading happens
+        @read_lock.synchronize do
+          @data[key.to_s]
+        end
+      else
+        super
+      end
+    end
+
+    def respond_to?(method)
+      key = method.to_s.match(/.*=$/) ? method.to_s.match(/(.*)=$/)[1].to_sym : method.to_s.to_sym
+      
+      if structure.has_key?(key)
+        true
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/rffdb/document_collection.rb

@@ -0,0 +1,72 @@
+module RubyFFDB
+  class DocumentCollection
+    include Enumerable
+
+    # @return [Class] this is a collection of this {Document} subclass
+    attr_reader :type
+
+    # @param list [#to_a] the list of Documents to reference
+    # @param type [Class] the type of Document this collection references
+    def initialize(list, type = Document)
+      @list = list.to_a
+      @type = type
+    end
+
+    # Iterates over the list of Document instances
+    def each(&block)
+      @list.each(&block)
+    end
+    
+    # Returns the number of Document instances in the collection
+    # @return [Fixnum]
+    def size
+      @list.size
+    end
+
+    # Return the first item in the collection
+    # @return [Document] the first item in the collection
+    def first
+      @list.first
+    end
+
+    # Return the last item in the collection
+    # @return [Document] the last item in the collection
+    def last
+      @list.last
+    end
+
+    # Return the collection item at the specified index
+    # @return [Document,DocumentCollection] the item at the requested index
+    def [](index)
+      if index.kind_of?(Range)
+        self.class.new(@list[index], @type)
+      else
+        @list[index]
+      end
+    end
+
+    # Allow complex sorting like an Array
+    # @return [DocumentCollection] sorted collection
+    def sort(&block)
+      self.class.new(super(&block), @type)
+    end
+
+    # Horribly inefficient way to allow querying Documents by their attributes.
+    # This method can be chained for multiple / more specific queries.
+    #
+    # @param attribute [Symbol] the attribute to query
+    # @param value [Object] the value to compare against
+    # @param comparison_method [String,Symbol] the method to use for comparison - allowed options are "'==', '>', '>=', '<', '<=', and 'match'"
+    # @raise [Exceptions::InvalidWhereQuery] if not the right kind of comparison
+    # @return [DocumentCollection]
+    def where(attribute, value, comparison_method = '==')
+      unless [:'==', :'>', :'>=', :'<', :'<=', :match].include?(comparison_method.to_sym)
+        raise Exceptions::InvalidWhereQuery
+      end
+      self.class.new(
+        @list.collect {|item| item if item.send(attribute).send(comparison_method.to_sym, value) }.compact,
+        @type
+      )
+    end
+  end
+end

data/lib/rffdb/exception.rb

@@ -0,0 +1,5 @@
+module RubyFFDB
+  # Generic Exception definition. Any subclass *must* implement or inherit the methods defined here (if any).
+  class Exception < StandardError
+  end
+end

data/lib/rffdb/exceptions/cache_exceptions.rb

@@ -0,0 +1,9 @@
+module RubyFFDB
+  module Exceptions
+    class InvalidCacheSize < Exception
+    end
+
+    class InvalidCacheProvider < Exception
+    end
+  end
+end

data/lib/rffdb/exceptions/document_exceptions.rb

@@ -0,0 +1,22 @@
+module RubyFFDB
+  module Exceptions
+    class FailedValidation < Exception
+    end
+
+    class InvalidEngine < Exception
+    end
+
+    class InvalidInput < Exception
+    end
+
+    class InvalidWhereQuery < Exception
+    end
+
+    class NoSuchDocument < Exception
+    end
+
+    class PendingChanges < Exception
+    end
+  end
+end
+    

data/lib/rffdb/storage_engine.rb

@@ -0,0 +1,123 @@
+module RubyFFDB
+  # Generic Storage Engine definition. Any subclass *must* implement or inherit the methods defined here (if any).
+  class StorageEngine
+    # Read locking by document type
+    # @param type [Document] implements the equivalent of table-level read-locking on this {Document} type 
+    def self.read_lock(type, &block)
+      @read_mutexes ||= {}
+      @read_mutexes[type] ||= Mutex.new
+      @read_mutexes[type].synchronize(&block)
+    end
+
+    # Write locking by document type, with implicit read locking
+    # @param type [Document] implements the equivalent of table-level write-locking on this {Document} type
+    def self.write_lock(type, &block)
+      @write_mutexes ||= {}
+      @write_mutexes[type] ||= Mutex.new
+      @write_mutexes[type].synchronize do
+        read_lock(type, &block)
+      end
+    end
+
+    # Store data
+    # @param type [Document] type of {Document} to store
+    # @param object_id [Object] unique identifier for the data to store (usually an Integer)
+    # @param data [Object] data to be stored
+    def self.store(type, object_id, data)
+      false
+    end
+
+    # Retrieve some stored data
+    # @param type [Document] type of {Document} to retrieve
+    # @param object_id [Object] unique identifier for the stored data (usually an Integer)
+    # @param use_caching [Boolean] attempt to pull the data from cache (or not)
+    def self.retrieve(type, object_id, use_caching = true)
+      false
+    end
+
+    # Flush all changes to disk (usually done automatically)
+    def self.flush
+      false
+    end
+
+    # The full path to a stored (or would-be stored) {Document}
+    # @param type [Document] the document type
+    # @param object_id [Object] unique identifier for the document (usually an Integer)
+    def self.file_path(type, object_id)
+      false
+    end
+
+    # Return all known instances of a {Document}
+    # @param type [Document] the document type
+    # @return [Array]
+    def self.all(type)
+      []
+    end
+
+    # Determine the next unique identifier available for a {Document} type
+    # @param type [Document] the document type
+    # @return [Fixnum]
+    def self.next_id(type)
+      last_id = all(type)[-1]
+      next_key = last_id.nil? ? 1 : (last_id + 1)
+      if @highest_known_key and @highest_known_key >= next_key
+        write_lock(type) { @highest_known_key += 1 }
+      else
+        write_lock(type) { @highest_known_key = next_key }
+      end
+    end
+
+    # Set the cache provider to use for a document type
+    # This completely flushes all cache.
+    # @param document_type [Document] the document type
+    # @param cache_provider_class [CacheProvider] the type of {CacheProvider} to use
+    def self.cache_provider(document_type, cache_provider_class)
+      unless cache_provider_class.instance_of? Class and cache_provider_class.ancestors.include?(CacheProvider)
+        raise Exceptions::InvalidCacheProvider
+      end
+      @caches ||= {}
+      @caches[document_type] = cache_provider_class.new
+    end
+
+    # Set the maximum size of a cache, based on {Document} type
+    # @param type [Document] the document type
+    # @param size [Fixnum] the maximum size of the cache
+    def self.cache_size(type, size)
+      @caches ||= {}
+      if @caches.has_key?(type)
+        @caches[type] = @caches[type].class.new(size)
+      else
+        @caches[type] = CacheProviders::LRUCache.new(size)
+      end
+    end
+
+    # Attempt to retrieve an item from the {Document} type's cache instance
+    # @param type [Document] the document type
+    # @param object_id [Object] unique identifier for the document (usually an Integer)
+    def self.cache_lookup(type, object_id)
+      @caches ||= {}
+      @caches[type] ||= CacheProviders::LRUCache.new
+      @caches[type][object_id.to_s]
+    end
+
+    # Store some data in the cache for the {Document} type
+    # @param type [Document] the document type
+    # @param object_id [Object] unique identifier for the document (usually an Integer)
+    # @param data [Object] data to be stored
+    # @return [Boolean]
+    def self.cache_store(type, object_id, data)
+      @caches ||= {}
+      @caches[type] ||= CacheProviders::LRUCache.new
+      @caches[type][object_id.to_s] = data
+      return true
+    end
+
+    # Allow access to the cache instance directly (kind of dangerous but helpful for troubleshooting)
+    # @param type [Document] the document type
+    # @return [CacheProvider]
+    def self.cache(type)
+      @caches ||= {}
+      @caches[type] ||= CacheProviders::LRUCache.new
+    end
+  end
+end

data/lib/rffdb/storage_engines/json_engine.rb

@@ -0,0 +1,52 @@
+module RubyFFDB
+  module StorageEngines
+    class JsonEngine < StorageEngine
+      # TODO add support for sharding since directories will fill up quickly
+      require 'json'
+
+      def self.store(type, object_id, data)
+        path = file_path(type, object_id)
+        write_lock(type) do
+          FileUtils.mkdir_p(File.dirname(path))
+          File.open(path, "w") do |file|
+            file.puts JSON.dump(data)
+          end
+          cache_store(type, object_id, data)
+        end
+        return true
+      end
+
+      def self.retrieve(type, object_id, use_caching = true)
+        result = nil
+        begin
+          result = cache_lookup(type, object_id) if use_caching
+          unless result
+            read_lock(type) do
+              file = File.open(file_path(type, object_id), "r")
+              result = JSON.load(file)
+              file.close
+            end
+          end
+          cache_store(type, object_id, result)
+        rescue => e
+          puts e.message
+        end
+        return result.dup # Return a duplicate to support caching
+      end
+
+      # Lazily grab all document ids in use
+      def self.all(type)
+        directory_glob = read_lock(type) { Dir.glob(File.join(File.dirname(file_path(type, 0)), "*.json")) }
+        if directory_glob and !directory_glob.empty?
+          directory_glob.map {|doc| Integer(File.basename(doc, ".json"))}.sort
+        else
+          []
+        end
+      end
+
+      def self.file_path(type, object_id)
+        File.join(type.to_s.gsub('::', "__"), 'documents', object_id.to_s + ".json")
+      end
+    end
+  end
+end

data/lib/rffdb/storage_engines/yaml_engine.rb

@@ -0,0 +1,50 @@
+module RubyFFDB
+  module StorageEngines
+    class YamlEngine < StorageEngine
+      # TODO add support for sharding since directories will fill up quickly
+      require 'yaml'
+
+      def self.store(type, object_id, data)
+        path = file_path(type, object_id)
+        write_lock(type) do
+          FileUtils.mkdir_p(File.dirname(path))
+          File.open(path, "w") do |file|
+            file.puts YAML.dump(data)
+          end
+          cache_store(type, object_id, data)
+        end
+        return true
+      end
+
+      def self.retrieve(type, object_id, use_caching = true)
+        result = nil
+        begin
+          result = cache_lookup(type, object_id) if use_caching
+          read_lock(type) do
+            result ||= YAML.load_file(file_path(type, object_id))
+          end
+          write_lock(type) do
+            cache_store(type, object_id, result)
+          end
+        rescue => e
+          puts e.message
+        end
+        return result.dup # Return a duplicate to support caching
+      end
+
+      # Lazily grab all document ids in use
+      def self.all(type)
+        directory_glob = read_lock(type) { Dir.glob(File.join(File.dirname(file_path(type, 0)), "*.yml")) }
+        if directory_glob and !directory_glob.empty?
+          directory_glob.map {|doc| Integer(File.basename(doc, ".yml"))}.sort
+        else
+          []
+        end
+      end
+
+      def self.file_path(type, object_id)
+        File.join(type.to_s.gsub('::', "__"), 'documents', object_id.to_s + ".yml")
+      end
+    end
+  end
+end

data/lib/rffdb/version.rb

@@ -0,0 +1,3 @@
+module RubyFFDB
+  VERSION = "0.0.5"
+end

data/lib/rffdb.rb

@@ -0,0 +1,11 @@
+require 'ostruct'
+require 'rffdb/version'
+require 'rffdb/exception'
+require 'rffdb/exceptions/cache_exceptions'
+require 'rffdb/exceptions/document_exceptions'
+require 'rffdb/cache_provider'
+require 'rffdb/cache_providers/lru_cache'
+require 'rffdb/storage_engine'
+require 'rffdb/storage_engines/yaml_engine'
+require 'rffdb/document'
+require 'rffdb/document_collection'

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: rffdb
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Jonathan Gnagy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-30 00:00:00.000000000 Z
+dependencies: []
+description: A demonstration gem
+email: jonathan.gnagy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- lib/rffdb.rb
+- lib/rffdb/cache_provider.rb
+- lib/rffdb/cache_providers/lru_cache.rb
+- lib/rffdb/cache_providers/rr_cache.rb
+- lib/rffdb/document.rb
+- lib/rffdb/document_collection.rb
+- lib/rffdb/exception.rb
+- lib/rffdb/exceptions/cache_exceptions.rb
+- lib/rffdb/exceptions/document_exceptions.rb
+- lib/rffdb/storage_engine.rb
+- lib/rffdb/storage_engines/json_engine.rb
+- lib/rffdb/storage_engines/yaml_engine.rb
+- lib/rffdb/version.rb
+homepage: https://rubygems.org/gems/rffdb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: Ruby FlatFile DB
+test_files: []
+has_rdoc: