rffdb 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1663bc00dcb1ccd67c4e62f73367682709c603b3
-  data.tar.gz: ba8637b384bb8215977d852b5e1f0e483fd0f638
+  metadata.gz: 2ac408fa55b4135737e2c26d4d1ebdb208951278
+  data.tar.gz: 362c818f4cd7435d248f9ccbe5ce85c602f494de
 SHA512:
-  metadata.gz: 013ed8f87707dc0e6f71909951e646e20fc682d5851c60a447bff9975bd5e8620a7bc0b86a8d6a70b28150dd5a06935c26d119e3891af4959413cd370b12cccd
-  data.tar.gz: 98985078b1ed11cf51a28d11f1355b5ac056f8c82336f8af7229a935fd726cbe188c4d96b0ee6582b446b7ad419fcb033cda43c7fd03300f9d312c10025359b6
+  metadata.gz: c0fe51088853821a6a109b91386fc68f3ebae4e596304b14151179293d1976ebb5949d8f7d9e649d67784d327325c5d7d42f95e05e93b891afb0136d05fc06bf
+  data.tar.gz: b8412b293f6b541c728f1ce6bdf479a32a1482e15a154d5d40d09a489cade1340bd81150d702a7d7c2509e36e0c26686ecf75b5f3394c620a60af72d618d7e8a

data/lib/rffdb/cache_provider.rb

@@ -1,14 +1,15 @@
 module RubyFFDB
-  # Generic Cache Provider definition. Any subclass *must* implement or inherit the methods defined here (if any).
+  # 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)
+    def [](_key)
       nil
     end
-    
+
     # Used for storing data in the cache
-    def []=(key, value)
+    def []=(_key, _value)
       false
     end
   end
-end
+end

data/lib/rffdb/cache_providers/lru_cache.rb

@@ -1,16 +1,17 @@
 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.
+    # 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)
+        fail Exceptions::InvalidCacheSize unless max_size.is_a?(Integer)
 
         @max_size     = max_size
         @hits         = 0
@@ -55,7 +56,8 @@ module RubyFFDB
         to_hash.each(&block)
       end
 
-      # Invalidate a cached item by its index / key. Returns `nil` if the object doesn't exist.
+      # 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)
@@ -76,7 +78,8 @@ module RubyFFDB
         end
       end
 
-      # Similar to {#truncate} (in fact, it calls it) but it also clears the statistical metadata.
+      # 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
@@ -87,19 +90,26 @@ module RubyFFDB
         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`).
+      # 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 }}
+        {
+          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.
+      # 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
@@ -114,9 +124,7 @@ module RubyFFDB
             store(key, value)
           end
         else
-          if size >= @max_size
-            invalidate(@keys.first) until size < @max_size
-          end
+          invalidate(@keys.first) until size < @max_size if size >= @max_size
 
           @write_mutex.synchronize do
             @meta_mutex.synchronize { @keys << key }
@@ -127,13 +135,14 @@ module RubyFFDB
 
       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.
+      # Retrieve an item from the cache. Returns `nil` if the item does not
+      # 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
+          # Looks dumb, but it actually only reorganizes the keys Array
           store(key, @read_mutex.synchronize { @data[key] })
         else
           @meta_mutex.synchronize { @misses += 1 }
@@ -159,4 +168,4 @@ module RubyFFDB
       end
     end
   end
-end
+end

data/lib/rffdb/cache_providers/rr_cache.rb

@@ -1,15 +1,18 @@
 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.
+    # 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
+      # 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
@@ -32,4 +35,4 @@ module RubyFFDB
       alias_method :[]=, :store
     end
   end
-end
+end

data/lib/rffdb/constants.rb

@@ -1,4 +1,8 @@
 module RubyFFDB
   # Data directory for DB storage
-  DB_DATA = ENV["RFFDB_DB_DATA"] ? File.expand_path(ENV["RFFDB_DB_DATA"]) : File.expand_path(File.join("~", ".rffdb", "data"))
-end
+  DB_DATA = if ENV['RFFDB_DB_DATA']
+              File.expand_path(ENV['RFFDB_DB_DATA'])
+            else
+              File.expand_path(File.join('~', '.rffdb', 'data'))
+            end
+end

data/lib/rffdb/document.rb

@@ -1,11 +1,13 @@
 module RubyFFDB
   class Document
+    include Comparable
+    attr_reader :id
 
-    # @raise [Exceptions::NoSuchDocument] when attempting to retrieve a non-existing document by id
+    # @raise [Exceptions::NoSuchDocument] retrieved a non-existing document
     def initialize(existing_id = false, lazy = true)
       if existing_id
-        @document_id  = existing_id
-        raise Exceptions::NoSuchDocument unless File.exists?(file_path)
+        @id  = existing_id
+        fail Exceptions::NoSuchDocument unless File.exist?(file_path)
         if lazy
           @lazy = true
         else
@@ -14,7 +16,7 @@ module RubyFFDB
         end
         @saved = true
       else
-        @document_id = storage.next_id(self.class)
+        @id = storage.next_id(self.class)
         @data = {}
         # relative to database root
         @saved = false
@@ -23,16 +25,10 @@ module RubyFFDB
       @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)
+    # @return [String] flat-file used to store this document (may not exist yet)
     def file_path
-      storage.file_path(self.class, @document_id)
+      storage.file_path(self.class, @id)
     end
 
     # Commit the document to storage
@@ -40,7 +36,7 @@ module RubyFFDB
     def commit
       @read_lock.synchronize do
         @write_lock.synchronize do
-          storage.store(self.class, @document_id, @data.dup) unless @saved
+          storage.store(self.class, @id, @data.dup) unless @saved
           @saved = true
         end
       end
@@ -51,91 +47,118 @@ module RubyFFDB
     # Has this documented been committed to storage?
     # @return [Boolean]
     def committed?
-      return @saved
+      @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)
+    # 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
+      if committed? || force
         @read_lock.synchronize do
           @write_lock.synchronize do
-            @data = storage.retrieve(self.class, @document_id, false)
+            @data = storage.retrieve(self.class, @id, false)
           end
         end
       else
-        raise Exceptions::PendingChanges
+        fail 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.
+    # 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)
+        @data = storage.retrieve(self.class, @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)
+    # 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)
+      new(id)
     end
 
-    self.singleton_class.send(:alias_method, :get, :load)
+    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
+    # 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
+    # @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
+    # @option options [Boolean] :unique should this attribute be unique?
     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]] : []
+      @structure[name.to_sym][:class]   =
+        options.key?(:class) ? options[:class] : Object
+      @structure[name.to_sym][:format]  =
+        options.key?(:format) ? options[:format] : nil
+      @structure[name.to_sym][:validations] =
+        options.key?(:validate) ? [*options[:validate]] : []
+      @structure[name.to_sym][:unique] =
+        options.key?(:unique) == true ? true : false
     end
 
-    # This DSL method is used to setup the backend {StorageEngine} class and optionally the {CacheProvider}
-    # for this Document type.
+    # 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}
+    # @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)
+      unless storage_engine.instance_of?(Class) &&
+             storage_engine.ancestors.include?(StorageEngine)
+        fail Exceptions::InvalidEngine
+      end
       @engine = storage_engine
-      if cache_opts.has_key?(:cache_provider)
+      if cache_opts.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
+        unless cache_opts[:cache_provider].instance_of?(Class) &&
+               cache_opts[:cache_provider].ancestors.include?(CacheProvider)
+          fail 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
+
+      @engine.cache_size(
+        self, cache_opts[:cache_size]
+      ) if cache_opts.key?(:cache_size)
     end
 
-    # @return [StorageEngine] a reference to the storage engine singleton of this document class
+    # @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
+    # @return [StorageEngine] a reference to the storage engine singleton of
+    #   this document class
     def storage
       self.class.send(:storage)
     end
@@ -151,8 +174,8 @@ module RubyFFDB
       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.
+    # 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)
@@ -167,42 +190,64 @@ module RubyFFDB
     # 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)
+      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 = "==")
+    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
+    # Compare two documents
+    def <=>(other)
+      id <=> other.id
+    end
+
+    # Uses the defined schema to setup getter and setter methods. Runs
+    # validations, format checking, and type checking on setting methods.
+    # @todo refactor and comment better
+    # @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])
+      setter = method.to_s.match(/(.*)=$/) ? true : false
+      key = setter ? $1.to_sym : method.to_s.to_sym
+
+      if structure.key?(key) && setter
+        if args.last.is_a?(structure[key][:class]) &&
+           (
+             structure[key][:format].nil? ||
+             args.last.to_s.match(structure[key][:format])
+           )
           valid = true
+          if structure[key][:unique] == true
+            fail Exceptions::NotUnique unless test_uniqueness(key, args.last)
+          end
           structure[key][:validations].each do |validation|
-            valid = self.send(validation.to_sym, args.last)
-            raise Exceptions::FailedValidation unless valid
+            valid = send(validation.to_sym, args.last)
+            fail Exceptions::FailedValidation unless valid
           end
-          refresh if @read_lock.synchronize { @lazy } and @read_lock.synchronize { committed? } # here is where the lazy-loading happens
+          # here is where the lazy-loading happens
+          refresh if @read_lock.synchronize { @lazy } &&
+                     @read_lock.synchronize { committed? }
           @read_lock.synchronize do
             @write_lock.synchronize do
               @data[key.to_s] = args.last if valid
             end
           end
         else
-          raise Exceptions::InvalidInput
+          fail 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
+      elsif structure.key?(key)
+        # here is where the lazy-loading happens
+        refresh if @read_lock.synchronize { @lazy } &&
+                   @read_lock.synchronize { committed? }
         @read_lock.synchronize do
           @data[key.to_s]
         end
@@ -212,14 +257,30 @@ module RubyFFDB
     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)
+      key = method.to_s.match(/(.*)=$/) ? $1.to_sym : method.to_s.to_sym
+
+      if structure.key?(key)
         true
       else
         super
       end
     end
 
+    private
+
+    # check if a value is unique
+    # @return [Boolean] is the value for this column unique?
+    def test_uniqueness(column, value)
+      if committed?
+        (self.class.where(column.to_sym, value) - self).empty?
+      else
+        list = self.class.where(column.to_sym, value)
+        if list.size == 1
+          list.first.id == id
+        else
+          true
+        end
+      end
+    end
   end
-end
+end

data/lib/rffdb/document_collection.rb

@@ -1,6 +1,7 @@
 module RubyFFDB
   class DocumentCollection
     include Enumerable
+    include Comparable
 
     # @return [Class] this is a collection of this {Document} subclass
     attr_reader :type
@@ -16,7 +17,7 @@ module RubyFFDB
     def each(&block)
       @list.each(&block)
     end
-    
+
     # Returns the number of Document instances in the collection
     # @return [Fixnum]
     def size
@@ -38,13 +39,78 @@ module RubyFFDB
     # Return the collection item at the specified index
     # @return [Document,DocumentCollection] the item at the requested index
     def [](index)
-      if index.kind_of?(Range)
+      if index.is_a?(Range)
         self.class.new(@list[index], @type)
       else
         @list[index]
       end
     end
 
+    # Return a collection after subtracting from the original
+    # @return [DocumentCollection]
+    def -(other)
+      new_list = @list.dup
+      if other.respond_to?(:to_a)
+        other.to_a.each do |item|
+          new_list.delete_if { |document| document.id == item.id }
+        end
+      elsif other.is_a?(@type)
+        new_list.delete_if { |document| document.id == other.id }
+      else
+        fail Exceptions::InvalidInput
+      end
+      self.class.new(new_list, @type)
+    end
+
+    # Return a collection after adding to the original
+    #   Warning: this may cause duplicates or mixed type joins! For safety,
+    #   use #merge
+    # @return [DocumentCollection]
+    def +(other)
+      if other.respond_to?(:to_a)
+        self.class.new(@list + other.to_a, @type)
+      elsif other.is_a?(@type)
+        self.class.new(@list + [other], @type)
+      else
+        fail Exceptions::InvalidInput
+      end
+    end
+
+    # Merge two collections
+    # @return [DocumentCollection]
+    def merge(other)
+      if other.is_a?(self.class) && other.type == @type
+        new_list = []
+
+        new_keys = collect(&:id)
+        new_keys += other.collect(&:id)
+
+        new_keys.sort.uniq.each do |doc_id|
+          new_list << self.class.get(doc_id)
+        end
+
+        self.class.new(new_list, @type)
+      else
+        fail Exceptions::InvalidInput
+      end
+    end
+
+    # Allow comparison of collection
+    # @return [Boolean] do the collections contain the same document ids?
+    def ==(other)
+      if other.is_a? self.class
+        collect(&:id).sort == other.collect(&:id).sort
+      else
+        false
+      end
+    end
+
+    # Does the collection contain anything?
+    # @return [Boolean]
+    def empty?
+      @list.empty?
+    end
+
     # Allow complex sorting like an Array
     # @return [DocumentCollection] sorted collection
     def sort(&block)
@@ -56,17 +122,21 @@ module RubyFFDB
     #
     # @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'"
+    # @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
+      valid_comparison_methods = [:'==', :'>', :'>=', :'<', :'<=', :match]
+      unless valid_comparison_methods.include?(comparison_method.to_sym)
+        fail Exceptions::InvalidWhereQuery
       end
       self.class.new(
-        @list.collect {|item| item if item.send(attribute).send(comparison_method.to_sym, value) }.compact,
+        @list.collect do |item|
+          item if item.send(attribute).send(comparison_method.to_sym, value)
+        end.compact,
         @type
       )
     end
   end
-end
+end

data/lib/rffdb/exception.rb

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

data/lib/rffdb/exceptions/cache_exceptions.rb

@@ -6,4 +6,4 @@ module RubyFFDB
     class InvalidCacheProvider < Exception
     end
   end
-end
+end

data/lib/rffdb/exceptions/document_exceptions.rb

@@ -15,8 +15,10 @@ module RubyFFDB
     class NoSuchDocument < Exception
     end
 
+    class NotUnique < Exception
+    end
+
     class PendingChanges < Exception
     end
   end
 end
-    

data/lib/rffdb/storage_engine.rb

@@ -1,8 +1,10 @@
 module RubyFFDB
-  # Generic Storage Engine definition. Any subclass *must* implement or inherit the methods defined here (if any).
+  # 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 
+    # @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
@@ -10,7 +12,8 @@ module RubyFFDB
     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
+    # @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
@@ -20,37 +23,42 @@ module RubyFFDB
     end
 
     # Store data
+    # This method should be overridden in subclasses.
     # @param type [Document] type of {Document} to store
-    # @param object_id [Object] unique identifier for the data to store (usually an Integer)
+    # @param object_id [Object] unique identifier for the data to store
     # @param data [Object] data to be stored
-    def self.store(type, object_id, data)
+    def self.store(_type, _object_id, _data)
       false
     end
 
     # Retrieve some stored data
+    # This method should be overridden in subclasses.
     # @param type [Document] type of {Document} to retrieve
-    # @param object_id [Object] unique identifier for the stored data (usually an Integer)
+    # @param object_id [Object] unique identifier for the stored data
     # @param use_caching [Boolean] attempt to pull the data from cache (or not)
-    def self.retrieve(type, object_id, use_caching = true)
+    def self.retrieve(_type, _object_id, _use_caching = true)
       false
     end
 
     # Flush all changes to disk (usually done automatically)
+    # This method should be overridden in subclasses.
     def self.flush
       false
     end
 
     # The full path to a stored (or would-be stored) {Document}
+    # This method should be overridden in subclasses.
     # @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)
+    # @param object_id [Object] unique identifier for the document
+    def self.file_path(_type, _object_id)
       false
     end
 
     # Return all known instances of a {Document}
+    # This method should be overridden in subclasses.
     # @param type [Document] the document type
     # @return [Array]
-    def self.all(type)
+    def self.all(_type)
       []
     end
 
@@ -60,7 +68,7 @@ module RubyFFDB
     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
+      if @highest_known_key && @highest_known_key >= next_key
         write_lock(type) { @highest_known_key += 1 }
       else
         write_lock(type) { @highest_known_key = next_key }
@@ -70,10 +78,12 @@ module RubyFFDB
     # 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
+    # @param cache_provider_class [CacheProvider] the type {CacheProvider}
+    #   subclass for caching
     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
+      unless cache_provider_class.instance_of?(Class) &&
+             cache_provider_class.ancestors.include?(CacheProvider)
+        fail Exceptions::InvalidCacheProvider
       end
       @caches ||= {}
       @caches[document_type] = cache_provider_class.new
@@ -84,7 +94,7 @@ module RubyFFDB
     # @param size [Fixnum] the maximum size of the cache
     def self.cache_size(type, size)
       @caches ||= {}
-      if @caches.has_key?(type)
+      if @caches.key?(type)
         @caches[type] = @caches[type].class.new(size)
       else
         @caches[type] = CacheProviders::LRUCache.new(size)
@@ -93,7 +103,7 @@ module RubyFFDB
 
     # 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)
+    # @param object_id [Object] unique identifier for the document
     def self.cache_lookup(type, object_id)
       @caches ||= {}
       @caches[type] ||= CacheProviders::LRUCache.new
@@ -102,17 +112,18 @@ module RubyFFDB
 
     # 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 object_id [Object] unique identifier for the document
     # @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
+      true
     end
 
-    # Allow access to the cache instance directly (kind of dangerous but helpful for troubleshooting)
+    # 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)
@@ -120,4 +131,4 @@ module RubyFFDB
       @caches[type] ||= CacheProviders::LRUCache.new
     end
   end
-end
+end

data/lib/rffdb/storage_engines/json_engine.rb

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

data/lib/rffdb/storage_engines/yaml_engine.rb

@@ -1,19 +1,19 @@
 module RubyFFDB
   module StorageEngines
     class YamlEngine < StorageEngine
-      # TODO add support for sharding since directories will fill up quickly
+      # 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.open(path, 'w') do |file|
             file.puts YAML.dump(data)
           end
           cache_store(type, object_id, data)
         end
-        return true
+        true
       end
 
       def self.retrieve(type, object_id, use_caching = true)
@@ -29,22 +29,29 @@ module RubyFFDB
         rescue => e
           puts e.message
         end
-        return result.dup # Return a duplicate to support caching
+        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
+        directory_glob = read_lock(type) do
+          Dir.glob(File.join(File.dirname(file_path(type, 0)), '*.yml'))
+        end
+        if directory_glob && !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(DB_DATA, type.to_s.gsub('::', "__"), 'documents', object_id.to_s + ".yml")
+        File.join(
+          DB_DATA,
+          type.to_s.gsub('::', '__'),
+          'documents',
+          object_id.to_s + '.yml'
+        )
       end
     end
   end
-end
+end

data/lib/rffdb/version.rb

@@ -1,3 +1,3 @@
 module RubyFFDB
-  VERSION = "0.0.6"
-end
+  VERSION = [0, 0, 8].join('.')
+end

data/lib/rffdb.rb

@@ -9,4 +9,4 @@ require 'rffdb/cache_providers/lru_cache'
 require 'rffdb/storage_engine'
 require 'rffdb/storage_engines/yaml_engine'
 require 'rffdb/document'
-require 'rffdb/document_collection'
+require 'rffdb/document_collection'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rffdb
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.8
 platform: ruby
 authors:
 - Jonathan Gnagy
@@ -9,7 +9,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 date: 2014-06-30 00:00:00.000000000 Z
-dependencies: []
+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'
 description: A demonstration gem
 email: jonathan.gnagy@gmail.com
 executables: []