perpetuity 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8013375d75e8b9cdc7a171ff15c51624709b3ba
-  data.tar.gz: 5f2a8546b037800548e2ec5588302552ba09323d
+  metadata.gz: 99bbdaa723ccda7b072e0b224d45508ee85173f2
+  data.tar.gz: 1b1fef3e2811ee1516d36c97b82de71d524279dc
 SHA512:
-  metadata.gz: fbdf6dc761c95fffa557e4a430f0b711cd52bbedf1aecf8e85200d9287bd385f27620c7c61606597dc51044312929d4576ac063a9ecde7c223c087e6b2438851
-  data.tar.gz: 101f30e6be3207d717dc3e0d2cfbbf27b20793fc6550c2bdd2c998cd34175444eb68a3acc54443c35535950709f3a25b28c256bb201809237cd98fa97067c70f
+  metadata.gz: 3768caff24b90ecf53787b530ac59f95fa920275a43a15fc906c2770e3d78e3a3ad07360b4ae4fb55b6976060ad5a8e8ad1f4d35bf842447bfff4c114f6e7cf8
+  data.tar.gz: 441477056696558e7be0fc26e789f0f0d996e48b5df471529a315d610b1891ab0cf61ef174f9c60ad5e7bac86d5664da5871fa849b7b610d23a9895b1143fd7e

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## Version 0.7.1
+
+- Only unmarshal attributes that we marshaled to begin with. This disallows the use of false marshaled objects. — with [Kevin Sjöberg](https://github.com/KevinSjoberg)
+- Allow insertion of multiple objects in `Mapper#insert`
+- Alias `Retrieval#limit` as `Retrieval#take` for `Enumerable` compatibility
+- Leave result cache when branching to new retrievals if previous retrieval had triggered a query
+- Silence warnings (some still exist in Moped, unfortunately)
+- Add finding based on attribute truthiness. For example: `mapper.find { |obj| obj.name }` finds objects whose `name` is neither `nil` nor `false`.
+- When you remove an index call from the mapper DSL, `Mapper#reindex!` now removes that index from the DB
+- Previously activated indexes in the DB are converted to `Perpetuity::Attribute`s rather than stored in the format specific to the DB driver
+
 ## Version 0.7.0
 
 - Add `Perpetuity::RailsModel`, an ActiveModel-compliant mixin

data/lib/perpetuity/attribute.rb

@@ -1,7 +1,7 @@
 module Perpetuity
   class Attribute
     attr_reader :name, :type
-    def initialize(name, type, options = {})
+    def initialize(name, type=nil, options = {})
       @name = name
       @type = type
 

data/lib/perpetuity/mapper.rb

@@ -47,6 +47,12 @@ module Perpetuity
 
     def reindex!
       indexes.each { |index| data_source.activate_index! index }
+      (data_source.active_indexes(mapped_class) - indexes).reject do |index|
+        # TODO: Make this not MongoDB-specific
+        index.attribute.name.to_s == '_id'
+      end.each do |index|
+        data_source.remove_index index
+      end
     end
 
     def attributes
@@ -59,14 +65,26 @@ module Perpetuity
 
     def insert object
       raise "#{object} is invalid and cannot be persisted." unless self.class.validations.valid?(object)
-      serializable_attributes = serialize(object)
-      if o_id = object.instance_exec(&self.class.id)
-        serializable_attributes[:id] = o_id
+      objects = Array(object)
+      serialized_objects = objects.map do |obj|
+        attributes = serialize(obj)
+        if o_id = obj.instance_exec(&self.class.id)
+          attributes[:id] = o_id
+        end
+
+        attributes
       end
 
-      new_id = data_source.insert mapped_class, serializable_attributes
-      give_id_to object, new_id
-      new_id
+      new_ids = data_source.insert(mapped_class, serialized_objects)
+      objects.each_with_index do |obj, index|
+        give_id_to obj, new_ids[index]
+      end
+
+      if object.is_a? Array
+        new_ids
+      else
+        new_ids.first
+      end
     end
 
     def self.data_source(configuration=Perpetuity.configuration)
@@ -102,7 +120,7 @@ module Perpetuity
     end
 
     def select &block
-      retrieve data_source.query(&block).to_db
+      retrieve data_source.query(&block)
     end
 
     alias :find_all :select
@@ -127,7 +145,7 @@ module Perpetuity
     alias :detect :find
 
     def reject &block
-      retrieve data_source.negate_query(&block).to_db
+      retrieve data_source.negate_query(&block)
     end
 
     def delete object
@@ -192,7 +210,7 @@ module Perpetuity
     end
 
     def id_for object
-      object.instance_variable_get(:@id)
+      object.instance_variable_get(:@id) if persisted?(object)
     end
 
     def self.validate &block
@@ -221,8 +239,8 @@ module Perpetuity
 
     private
 
-    def retrieve criteria={}
-      Perpetuity::Retrieval.new self, criteria
+    def retrieve query=data_source.query
+      Perpetuity::Retrieval.new self, query
     end
   end
 end

data/lib/perpetuity/mapper_registry.rb

@@ -16,9 +16,10 @@ module Perpetuity
         unless @mappers.has_key? klass
           raise KeyError, "No mapper for #{klass}"
         end
+        @mappers[klass]
       end
 
-      @mappers[klass].new(self)
+      mapper_class.new(self)
     end
 
     def []= klass, mapper
@@ -26,7 +27,7 @@ module Perpetuity
     end
 
     def each &block
-      @mappers.each &block
+      @mappers.each(&block)
     end
 
     def load_mappers

data/lib/perpetuity/mongodb/nil_query.rb

@@ -0,0 +1,11 @@
+module Perpetuity
+  class NilQuery
+    def self.new
+      @instance ||= allocate
+    end
+
+    def to_db
+      {}
+    end
+  end
+end

data/lib/perpetuity/mongodb/query.rb

@@ -1,10 +1,16 @@
 require 'perpetuity/mongodb/query_attribute'
+require 'perpetuity/mongodb/nil_query'
 
 module Perpetuity
   class MongoDB
     class Query
+      attr_reader :query
       def initialize &block
-        @query = block.call(self)
+        if block_given?
+          @query = block.call(self)
+        else
+          @query = NilQuery.new
+        end
       end
 
       def to_db
@@ -18,6 +24,10 @@ module Perpetuity
       def method_missing missing_method
         QueryAttribute.new missing_method
       end
+
+      def == other
+        query == other.query
+      end
     end
   end
 end

data/lib/perpetuity/mongodb/query_attribute.rb

@@ -46,6 +46,10 @@ module Perpetuity
         name
       end
 
+      def to_db
+        ((self != false) & (self != nil)).to_db
+      end
+
       def method_missing name
         if name.to_s == 'id'
           name = :"#{self.name}.__metadata__.#{name}"

data/lib/perpetuity/mongodb/query_expression.rb

@@ -4,7 +4,7 @@ require 'perpetuity/mongodb/query_intersection'
 module Perpetuity
   class MongoDB
     class QueryExpression
-      attr_accessor :comparator, :negated
+      attr_accessor :attribute, :comparator, :negated, :value
 
       def initialize attribute, comparator, value
         @attribute = attribute
@@ -82,6 +82,13 @@ module Perpetuity
         expr.negated = true
         expr
       end
+
+      def == other
+        attribute == other.attribute &&
+        comparator == other.comparator &&
+        value == other.value &&
+        negated == other.negated
+      end
     end
   end
 end

data/lib/perpetuity/mongodb/serializer.rb

@@ -36,7 +36,7 @@ module Perpetuity
           elsif mapper_registry.has_mapper?(value.class)
             serialize_with_foreign_mapper(value, attrib.embedded?)
           else
-            Marshal.dump(value)
+            marshal(value)
           end
 
           [attrib.name.to_s, serialized_value]
@@ -76,25 +76,26 @@ module Perpetuity
       end
 
       def unserialize_attribute data
-        if data.is_a?(String) && data.start_with?("\u0004") # if it's marshaled
-          Marshal.load(data)
-        elsif data.is_a? Array
-          data.map { |i| unserialize_attribute i }
-        elsif data.is_a? Hash
-          metadata = data.delete('__metadata__')
-          if metadata
-            klass = metadata['class'].split('::').inject(Kernel) do |scope, const_name|
-              scope.const_get(const_name)
-            end
-            id = metadata['id']
+        return data.map { |i| unserialize_attribute i } if data.is_a? Array
+        return data unless data.is_a? Hash
+        metadata  = data.fetch("__metadata__", {})
+        marshaled = data.fetch("__marshaled__", false)
+
+        if marshaled
+          value = data.fetch("value")
+          return unmarshal(value)
+        end
 
-            if id
-              object = Reference.new(klass, id)
-            else
-              object = unserialize_object(data, klass)
-            end
+        if metadata.any?
+          klass = metadata['class'].split('::').inject(Kernel) do |scope, const_name|
+            scope.const_get(const_name)
+          end
+          id = metadata['id']
+
+          if id
+            Reference.new(klass, id)
           else
-            data
+            unserialize_object(data, klass)
           end
         else
           data
@@ -131,7 +132,7 @@ module Perpetuity
               serialize_reference value
             end
           else
-            Marshal.dump(value)
+            marshal value
           end
         end
       end
@@ -152,6 +153,17 @@ module Perpetuity
           }
         }
       end
+
+      def marshal value
+        {
+          '__marshaled__' => true,
+          'value' => Marshal.dump(value)
+        }
+      end
+
+      def unmarshal value
+        Marshal.load(value)
+      end
     end
   end
 end

data/lib/perpetuity/mongodb.rb

@@ -1,9 +1,11 @@
 require 'moped'
 require 'perpetuity/mongodb/query'
+require 'perpetuity/mongodb/nil_query'
 require 'perpetuity/mongodb/index'
 require 'perpetuity/mongodb/serializer'
 require 'set'
 require 'perpetuity/exceptions/duplicate_key_error'
+require 'perpetuity/attribute'
 
 module Perpetuity
   class MongoDB
@@ -45,11 +47,18 @@ module Perpetuity
       database[klass.to_s]
     end
 
-    def insert klass, attributes
-      attributes[:_id] = attributes.delete(:id) || Moped::BSON::ObjectId.new
+    def insert klass, objects
+      if objects.is_a? Array
+        objects.each do |object|
+          object[:_id] = object.delete(:id) || Moped::BSON::ObjectId.new
+        end
+
+        collection(klass).insert objects
+        objects.map { |object| object[:_id] }
+      else
+        insert(klass, [objects]).first
+      end
 
-      collection(klass).insert attributes
-      attributes[:_id]
     rescue Moped::Errors::OperationFailure => e
       if e.message =~ /duplicate key/
         e.message =~ /\$(\w+)_\d.*dup key: { : (.*) }/
@@ -59,8 +68,8 @@ module Perpetuity
       end
     end
 
-    def count klass, criteria={}, &block
-      q = block_given? ? query(&block).to_db : criteria
+    def count klass, criteria=nil_query, &block
+      q = block_given? ? query(&block).to_db : criteria.to_db
       collection(klass).find(q).count
     end
 
@@ -77,7 +86,7 @@ module Perpetuity
 
     def retrieve klass, criteria, options = {}
       # MongoDB uses '_id' as its ID field.
-      criteria = to_bson_id(criteria)
+      criteria = to_bson_id(criteria.to_db)
 
       skipped = options.fetch(:skip) { 0 }
 
@@ -129,7 +138,7 @@ module Perpetuity
     end
 
     def all klass
-      retrieve klass, {}, {}
+      retrieve klass, nil_query, {}
     end
     
     def delete id, klass
@@ -152,6 +161,10 @@ module Perpetuity
       Query.new(&block)
     end
 
+    def nil_query
+      NilQuery.new
+    end
+
     def negate_query &block
       Query.new(&block).negate
     end
@@ -173,7 +186,7 @@ module Perpetuity
         key = index['key'].keys.first
         direction = index['key'][key]
         unique = index['unique']
-        Index.new(klass, key, order: Index::KEY_ORDERS[direction], unique: unique)
+        Index.new(klass, Attribute.new(key), order: Index::KEY_ORDERS[direction], unique: unique)
       end.to_set
     end
 

data/lib/perpetuity/retrieval.rb

@@ -3,12 +3,12 @@ require 'perpetuity/reference'
 module Perpetuity
   class Retrieval
     include Enumerable
-    attr_accessor :sort_attribute, :sort_direction, :result_limit, :result_page, :result_offset
+    attr_accessor :sort_attribute, :sort_direction, :result_limit, :result_page, :result_offset, :result_cache
 
-    def initialize mapper, criteria
+    def initialize mapper, query
       @mapper = mapper
       @class = mapper.mapped_class
-      @criteria = criteria
+      @query = query
       @data_source = mapper.data_source
     end
     
@@ -16,6 +16,7 @@ module Perpetuity
       retrieval = clone
       retrieval.sort_attribute = attribute
       retrieval.sort_direction = :ascending
+      retrieval.clear_cache
 
       retrieval
     end
@@ -23,6 +24,7 @@ module Perpetuity
     def reverse
       retrieval = clone
       retrieval.sort_direction = retrieval.sort_direction == :descending ? :ascending : :descending
+      retrieval.clear_cache
 
       retrieval
     end
@@ -32,6 +34,7 @@ module Perpetuity
       retrieval.result_limit ||= 20
       retrieval.result_page = page
       retrieval.result_offset = (page - 1) * retrieval.result_limit
+      retrieval.clear_cache
       retrieval
     end
 
@@ -39,6 +42,7 @@ module Perpetuity
       retrieval = clone
       retrieval.result_limit = per
       retrieval.result_offset = (retrieval.result_page - 1) * per
+      retrieval.clear_cache
       retrieval
     end
 
@@ -47,11 +51,11 @@ module Perpetuity
     end
 
     def to_a
-      @results ||= @data_source.unserialize(@data_source.retrieve(@class, @criteria, options), @mapper)
+      @result_cache ||= @data_source.unserialize(@data_source.retrieve(@class, @query, options), @mapper)
     end
 
     def count
-      @data_source.count(@class, @criteria)
+      @data_source.count(@class, @query)
     end
 
     def first
@@ -84,15 +88,22 @@ module Perpetuity
     def limit lim
       retrieval = clone
       retrieval.result_limit = lim
+      retrieval.clear_cache
       
       retrieval
     end
+    alias_method :take, :limit
 
     def drop count
       retrieval = clone
       retrieval.result_offset = count
+      retrieval.clear_cache
 
       retrieval
     end
+
+    def clear_cache
+      @result_cache = nil
+    end
   end
 end

data/lib/perpetuity/version.rb

@@ -1,3 +1,3 @@
 module Perpetuity
-  VERSION = "0.7.0"
+  VERSION = "0.7.1"
 end

data/spec/integration/indexing_spec.rb

@@ -8,6 +8,13 @@ describe 'indexing' do
       index :name, unique: true
     end
   end
+  let(:mapper_class_without_index) do
+    klass = mapper_class.dup
+    klass.new.indexes.reject! do |index|
+      index.attribute.name == :name
+    end
+    klass
+  end
   let(:mapper) { mapper_class.new }
   let(:name_index) do
     mapper.indexes.find do |index|
@@ -39,5 +46,14 @@ describe 'indexing' do
   it 'specifies uniqueness of the index' do
     name_index.should be_unique
   end
+
+  it 'removes other indexes' do
+    mapper.reindex!
+    mapper_without_index = mapper_class_without_index.new
+    mapper_without_index.reindex!
+    mapper.data_source.active_indexes(Object).any? do |index|
+      index.attribute.name.to_s == 'name'
+    end.should be_false
+  end
 end
 

data/spec/integration/mongodb_spec.rb

@@ -48,6 +48,15 @@ module Perpetuity
       its(:password)  { should == password }
     end
 
+    it 'inserts documents into a collection' do
+      expect { mongo.insert klass, name: 'foo' }.to change { mongo.count klass }.by 1
+    end
+
+    it 'inserts multiple documents into a collection' do
+      expect { mongo.insert klass, [{name: 'foo'}, {name: 'bar'}] }
+        .to change { mongo.count klass }.by 2
+    end
+
     it 'removes all documents from a collection' do
       mongo.insert klass, {}
       mongo.delete_all klass
@@ -77,7 +86,7 @@ module Perpetuity
 
     it 'gets all of the documents in a collection' do
       values = [{value: 1}, {value: 2}]
-      mongo.should_receive(:retrieve).with(Object, {}, {})
+      mongo.should_receive(:retrieve).with(Object, mongo.nil_query, {})
            .and_return(values)
       mongo.all(Object).should == values
     end
@@ -86,7 +95,7 @@ module Perpetuity
       time = Time.now.utc
       id = mongo.insert Object, {inserted: time}
 
-      object = mongo.retrieve(Object, id: id.to_s).first
+      object = mongo.retrieve(Object, mongo.query{|o| o.id == id.to_s }).first
       retrieved_time = object["inserted"]
       retrieved_time.to_f.should be_within(0.001).of time.to_f
     end
@@ -148,9 +157,10 @@ module Perpetuity
         id = mongo.insert klass, count: 1
         mongo.increment klass, id, :count
         mongo.increment klass, id, :count, 10
-        mongo.retrieve(klass, id: id).first['count'].should == 12
+        query = mongo.query { |o| o.id == id }
+        mongo.retrieve(klass, query).first['count'].should be == 12
         mongo.increment klass, id, :count, -1
-        mongo.retrieve(klass, id: id).first['count'].should == 11
+        mongo.retrieve(klass, query).first['count'].should be == 11
       end
     end
 

data/spec/integration/persistence_spec.rb

@@ -11,6 +11,13 @@ describe 'Persistence' do
     mapper.find(mapper.id_for(article)).title.should eq 'I have a title'
   end
 
+  it 'persists multiple objects' do
+    mapper.delete_all
+    articles = 2.times.map { Article.new(SecureRandom.hex) }
+    expect { mapper.insert articles }.to change { mapper.count }.by 2
+    mapper.all.sort(:title).to_a.should == articles.sort_by(&:title)
+  end
+
   it 'returns the id of the persisted object' do
     article = Article.new
     mapper.insert(article).should eq mapper.id_for(article)

data/spec/integration/retrieval_spec.rb

@@ -53,71 +53,90 @@ describe "retrieval" do
   end
 
   describe "Array-like syntax" do
-    let(:draft) { Article.new 'Draft', 'draft content', nil, Time.now + 30 }
-    let(:published) { Article.new 'Published', 'content', nil, Time.now - 30, 3 }
-
-    let(:published_id) { mapper.id_for published }
-    let(:draft_id) { mapper.id_for draft }
-
-    before do
-      mapper.insert draft
-      mapper.insert published
-    end
-
-    it 'selects objects using equality' do
-      selected = mapper.select { |article| article.title == 'Published' }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should include published_id
-      ids.should_not include draft_id
-    end
-
-    it 'selects objects using greater-than' do
-      selected = mapper.select { |article| article.published_at < Time.now }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should include published_id
-      ids.should_not include draft_id
-    end
-
-    it 'selects objects using greater-than-or-equal' do
-      selected = mapper.select { |article| article.views >= 3 }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should include published_id
-      ids.should_not include draft_id
-    end
-
-    it 'selects objects using less-than' do
-      selected = mapper.select { |article| article.views < 3 }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should include draft_id
-      ids.should_not include published_id
-    end
-
-    it 'selects objects using less-than-or-equal' do
-      selected = mapper.select { |article| article.views <= 0 }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should include draft_id
-      ids.should_not include published_id
-    end
-
-    it 'selects objects using inequality' do
-      selected = mapper.select { |article| article.title != 'Draft' }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should_not include draft_id
-      ids.should include published_id
-    end
-
-    it 'selects objects using regular expressions' do
-      selected = mapper.select { |article| article.title =~ /Pub/ }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should include published_id
-      ids.should_not include draft_id
-    end
-
-    it 'selects objects using inclusion' do
-      selected = mapper.select { |article| article.title.in %w( Published ) }
-      ids = selected.map { |article| mapper.id_for article }
-      ids.should include published_id
-      ids.should_not include draft_id
+    describe 'using comparison operators' do
+      let(:draft) { Article.new 'Draft', 'draft content', nil, Time.now + 30 }
+      let(:published) { Article.new 'Published', 'content', nil, Time.now - 30, 3 }
+
+      let(:published_id) { mapper.id_for published }
+      let(:draft_id) { mapper.id_for draft }
+
+      before do
+        mapper.insert draft
+        mapper.insert published
+      end
+
+      it 'selects objects using equality' do
+        selected = mapper.select { |article| article.title == 'Published' }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should include published_id
+        ids.should_not include draft_id
+      end
+
+      it 'selects objects using greater-than' do
+        selected = mapper.select { |article| article.published_at < Time.now }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should include published_id
+        ids.should_not include draft_id
+      end
+
+      it 'selects objects using greater-than-or-equal' do
+        selected = mapper.select { |article| article.views >= 3 }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should include published_id
+        ids.should_not include draft_id
+      end
+
+      it 'selects objects using less-than' do
+        selected = mapper.select { |article| article.views < 3 }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should include draft_id
+        ids.should_not include published_id
+      end
+
+      it 'selects objects using less-than-or-equal' do
+        selected = mapper.select { |article| article.views <= 0 }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should include draft_id
+        ids.should_not include published_id
+      end
+
+      it 'selects objects using inequality' do
+        selected = mapper.select { |article| article.title != 'Draft' }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should_not include draft_id
+        ids.should include published_id
+      end
+
+      it 'selects objects using regular expressions' do
+        selected = mapper.select { |article| article.title =~ /Pub/ }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should include published_id
+        ids.should_not include draft_id
+      end
+
+      it 'selects objects using inclusion' do
+        selected = mapper.select { |article| article.title.in %w( Published ) }
+        ids = selected.map { |article| mapper.id_for article }
+        ids.should include published_id
+        ids.should_not include draft_id
+      end
+    end
+
+    it 'selects objects that are truthy' do
+      article_with_truthy_title = Article.new('I have a title')
+      article_with_false_title = Article.new(false)
+      article_with_nil_title = Article.new(nil)
+
+      false_id  = mapper.insert article_with_false_title
+      truthy_id = mapper.insert article_with_truthy_title
+      nil_id    = mapper.insert article_with_nil_title
+
+      selected = mapper.select { |article| article.title }
+      ids = selected.map { |article| mapper.id_for(article) }
+
+      ids.should     include truthy_id
+      ids.should_not include false_id
+      ids.should_not include nil_id
     end
   end
 
@@ -180,7 +199,7 @@ describe "retrieval" do
     user = User.new(first_name: 'foo', last_name: 'bar')
     mapper = Perpetuity[User]
     mapper.insert user
-    users = mapper.select { |user| user.name.first_name == 'foo' }
+    users = mapper.select { |u| u.name.first_name == 'foo' }
     ids = users.map { |retrieved_user| mapper.id_for(retrieved_user) }
     ids.should include mapper.id_for(user)
   end
@@ -203,4 +222,13 @@ describe "retrieval" do
       articles.should include mapper.sample
     end
   end
+
+  it 'does not unmarshal objects that were saved as strings' do
+    fake_title = Marshal.dump(Object.new)
+    id = mapper.insert Article.new(fake_title)
+
+    retrieved = mapper.find(id)
+    retrieved.title.should be_a String
+    retrieved.title.should == fake_title
+  end
 end

data/spec/integration/update_spec.rb

@@ -53,8 +53,8 @@ describe 'updating' do
     mapper.save retrieved_book
 
     retrieved_authors = Perpetuity[Book].find(mapper.id_for retrieved_book).authors
-    retrieved_authors.map(&:klass).should == [User, User]
-    retrieved_authors.map(&:id).should == [mapper.id_for(dave), mapper.id_for(andy)]
+    retrieved_authors.map(&:klass).should be == [User, User]
+    retrieved_authors.map(&:id).should be == [mapper.id_for(dave), mapper.id_for(andy)]
   end
 
   describe 'atomic increments/decrements' do

data/spec/perpetuity/dereferencer_spec.rb

@@ -30,6 +30,8 @@ module Perpetuity
 
     context 'with multiple references' do
       it 'returns the array of dereferenced objects' do
+        first.instance_variable_set :@id, 1
+        second.instance_variable_set :@id, 2
         mapper.should_receive(:select) { objects }
         derefer.load([first_ref, second_ref]).should == objects
       end

data/spec/perpetuity/mapper_spec.rb

@@ -48,8 +48,8 @@ module Perpetuity
         data_source.should_receive(:can_serialize?).with('foo') { true }
         data_source.should_receive(:insert)
                    .with(Object,
-                         { 'my_attribute' => 'foo' })
-                   .and_return('bar')
+                         [{ 'my_attribute' => 'foo' }])
+                   .and_return(['bar'])
 
         mapper.insert(obj).should be == 'bar'
       end
@@ -61,10 +61,11 @@ module Perpetuity
 
       describe 'finding a single object' do
         let(:options) { {:attribute=>nil, :direction=>nil, :limit=>1, :skip=>nil} }
-        let(:returned_object) { double('Retrieved Object', class: Object) }
+        let(:returned_object) { double('Retrieved Object', class: Object, delete: nil) }
 
         it 'finds an object by ID' do
-          criteria = { id: 1 }
+          returned_object.instance_variable_set :@id, 1
+          criteria = data_source.query { |o| o.id == 1 }
           data_source.should_receive(:retrieve)
                      .with(Object, criteria, options) { [returned_object] }
 
@@ -72,26 +73,26 @@ module Perpetuity
         end
 
         it 'finds multiple objects with a block' do
-          criteria = { name: 'foo' }
+          criteria = data_source.query { |o| o.name == 'foo' }
           options = self.options.merge(limit: nil)
           data_source.should_receive(:retrieve)
                      .with(Object, criteria, options) { [returned_object] }.twice
 
-          mapper.select   { |e| e.name == 'foo' }.to_a.should == [returned_object]
-          mapper.find_all { |e| e.name == 'foo' }.to_a.should == [returned_object]
+          mapper.select   { |e| e.name == 'foo' }.to_a.should be == [returned_object]
+          mapper.find_all { |e| e.name == 'foo' }.to_a.should be == [returned_object]
         end
 
         it 'finds an object with a block' do
-          criteria = { name: 'foo' }
+          criteria = data_source.query { |o| o.name == 'foo' }
           data_source.should_receive(:retrieve)
                      .with(Object, criteria, options) { [returned_object] }.twice
-          mapper.find   { |o| o.name == 'foo' }.should == returned_object
-          mapper.detect { |o| o.name == 'foo' }.should == returned_object
+          mapper.find   { |o| o.name == 'foo' }.should be == returned_object
+          mapper.detect { |o| o.name == 'foo' }.should be == returned_object
         end
 
         it 'caches results' do
           mapper.give_id_to returned_object, 1
-          criteria = { id: 1 }
+          criteria = data_source.query { |o| o.id == 1 }
           data_source.should_receive(:retrieve)
                      .with(Object, criteria, options) { [returned_object] }
                      .once
@@ -101,7 +102,7 @@ module Perpetuity
         end
 
         it 'does not cache nil results' do
-          criteria = { id: 1 }
+          criteria = data_source.query { |o| o.id == 1 }
           data_source.should_receive(:retrieve)
                      .with(Object, criteria, options) { [] }
                      .twice

data/spec/perpetuity/mongodb/query_attribute_spec.rb

@@ -50,5 +50,9 @@ module Perpetuity
     it 'checks for inclusion' do
       (attribute.in [1, 2, 3]).should be_a MongoDB::QueryExpression
     end
+
+    it 'checks for its own truthiness' do
+      attribute.to_db.should == ((attribute != false) & (attribute != nil)).to_db
+    end
   end
 end

data/spec/perpetuity/mongodb/serializer_spec.rb

@@ -63,11 +63,7 @@ module Perpetuity
 
       context 'with objects that have hashes as attributes' do
         let(:name_data) { {first_name: 'Jamie', last_name: 'Gaskins'} }
-        let(:serialized_data) do
-          {
-            'name' => name_data
-          }
-        end
+        let(:serialized_data) { { 'name' => name_data } }
         let(:user) { User.new(name_data) }
         let(:user_serializer) { Serializer.new(user_mapper) }
 
@@ -86,21 +82,6 @@ module Perpetuity
         end
       end
 
-      describe 'unserializes attributes' do
-        let(:unserializable_object) { 1.to_c }
-        let(:serialized_attrs) { [ Marshal.dump(unserializable_object) ] }
-        let(:objects) { serializer.unserialize(serialized_attrs)  }
-        subject { objects.first }
-
-        before do
-          user_mapper.stub(data_source: data_source)
-          book_mapper.stub(data_source: data_source)
-        end
-
-        it { should be_a Complex }
-        it { should eq unserializable_object}
-      end
-
       describe 'with an array of references' do
         let(:author) { Reference.new(User, 1) }
         let(:title) { 'title' }
@@ -147,6 +128,73 @@ module Perpetuity
           serializer.serialize(car).should == { 'model' => car_model }
         end
       end
+
+      context 'with marshaled data' do
+        let(:unserializable_value) { 1..10 }
+
+        it 'stores metadata with marshal information' do
+          book = Book.new(unserializable_value)
+
+          book_mapper.stub(data_source: data_source)
+          data_source.stub(:can_serialize?).with(book.title) { false }
+
+          serializer.serialize(book).should == {
+            'title' => {
+              '__marshaled__' => true,
+              'value' => Marshal.dump(unserializable_value)
+            },
+            'authors' => []
+          }
+        end
+
+        it 'stores marshaled attributes within arrays' do
+          book = Book.new([unserializable_value])
+          book_mapper.stub(data_source: data_source)
+          data_source.stub(:can_serialize?).with(book.title.first) { false }
+
+          serializer.serialize(book).should == {
+            'title' => [{
+              '__marshaled__' => true,
+              'value' => Marshal.dump(unserializable_value)
+            }],
+            'authors' => []
+          }
+        end
+
+        it 'unmarshals data that has been marshaled by the serializer' do
+          data = {
+            'title' => {
+              '__marshaled__' => true,
+              'value' => Marshal.dump(unserializable_value),
+            }
+          }
+          serializer.unserialize(data).title.should be_a unserializable_value.class
+        end
+
+        it 'does not unmarshal data not marshaled by the serializer' do
+          data = { 'title' => Marshal.dump(unserializable_value) }
+
+          serializer.unserialize(data).title.should be_a String
+        end
+      end
+
+      it 'unserializes a hash of primitives' do
+        time = Time.now
+        serialized_data = {
+          'number' => 1,
+          'string' => 'hello',
+          'boolean' => true,
+          'float' => 7.5,
+          'time' => time
+        }
+
+        object = serializer.unserialize(serialized_data)
+        object.instance_variable_get(:@number).should == 1
+        object.instance_variable_get(:@string).should == 'hello'
+        object.instance_variable_get(:@boolean).should == true
+        object.instance_variable_get(:@float).should == 7.5
+        object.instance_variable_get(:@time).should == time
+      end
     end
   end
 end

data/spec/perpetuity/rails_model_spec.rb

@@ -18,34 +18,34 @@ module Perpetuity
     end
 
     it 'returns the id as to_param' do
-      object.to_param.should == nil
+      object.to_param.should be == nil
       object.id = 'foo'
-      object.to_param.should == 'foo'
+      object.to_param.should be == 'foo'
     end
 
     it 'returns the keys on the object' do
-      object.to_key.should == nil
+      object.to_key.should be == nil
       object.id = 'bar'
-      object.to_key.should == ['bar']
+      object.to_key.should be == ['bar']
     end
 
     it 'returns the model name' do
-      klass.model_name.should == klass
+      klass.model_name.should be == klass
     end
 
     it 'returns the param_key' do
       stub_const 'Foo::Bar', klass
-      Foo::Bar.param_key.should == 'foo_bar'
+      Foo::Bar.param_key.should be == 'foo_bar'
     end
 
     it 'returns the route_key' do
       stub_const 'Foo::Bar', klass
-      Foo::Bar.route_key.should == 'foo_bars'
+      Foo::Bar.route_key.should be == 'foo_bars'
     end
 
     it 'returns the singular_route_key' do
       stub_const 'Foo::Bar', klass
-      Foo::Bar.singular_route_key.should == 'foo_bar'
+      Foo::Bar.singular_route_key.should be == 'foo_bar'
     end
   end
 end

data/spec/perpetuity/retrieval_spec.rb

@@ -5,7 +5,8 @@ module Perpetuity
     let(:data_source) { double('data_source') }
     let(:registry) { double('mapper_registry') }
     let(:mapper) { double(mapped_class: Object, data_source: data_source, mapper_registry: registry) }
-    let(:retrieval) { Perpetuity::Retrieval.new mapper, {} }
+    let(:query) { double('Query', to_db: {}) }
+    let(:retrieval) { Perpetuity::Retrieval.new mapper, query }
     subject { retrieval }
 
     it "sorts the results" do
@@ -53,12 +54,18 @@ module Perpetuity
       return_object.stub(id: return_data[:id])
       options = { attribute: nil, direction: nil, limit: nil, skip: nil }
 
-      data_source.should_receive(:retrieve).with(Object, {}, options).
+      data_source.should_receive(:retrieve).with(Object, query, options).
                   and_return([return_data])
       data_source.should_receive(:unserialize).with([return_data], mapper) { [return_object] }
       results = retrieval.to_a
 
       results.map(&:id).should == [0]
     end
+
+    it 'clears results cache' do
+      retrieval.result_cache = [1,2,3]
+      retrieval.clear_cache
+      retrieval.result_cache.should be_nil
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: perpetuity
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Jamie Gaskins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-21 00:00:00.000000000 Z
+date: 2013-08-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -79,6 +79,7 @@ files:
 - lib/perpetuity/mapper_registry.rb
 - lib/perpetuity/mongodb.rb
 - lib/perpetuity/mongodb/index.rb
+- lib/perpetuity/mongodb/nil_query.rb
 - lib/perpetuity/mongodb/query.rb
 - lib/perpetuity/mongodb/query_attribute.rb
 - lib/perpetuity/mongodb/query_expression.rb
@@ -159,7 +160,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.5
 signing_key: 
 specification_version: 4
 summary: Persistence library allowing serialization of Ruby objects