perpetuity 0.4.8 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 70280878bf3a3182433a66c2133a364fbbc97e25
+  data.tar.gz: f953bdae10c21cf728ab816f6eb250a5c0553abd
+SHA512:
+  metadata.gz: 16bc5960f1be6d9d120c463c7f0310e732db0c30e8a40cef4ad8d2d9d06db0008318561f595653f5a5debfba98e4b40cc17453aa38698ec2c42b51800e5bb50e
+  data.tar.gz: e4ba4d28aefc0445bc5fbd3ddef864f7a29645389d448878c94d91eb17713f8c19a815efac7c3b9eae259514bdc1822d1be10e1d99ad7f574af97b35b34378f8

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## Version 0.5.0
+
+- Allow querying based on referenced class/id or embedded-object data
+- Remove duplicate references when loading associations on referenced objects
+- Optimize loading associations with zero/one/many objects. It is similar to `Array#detect` vs `Array#select`. `detect` is faster if you only need one.
+- Fixed a bug in defining methods on generated mapper classes which would mistakenly define them on the class instead of the mapper objects
+- Add `none?`/`one?`/`all?`/`any?` methods to mappers.
+- Add block functionality to `Mapper#count`, similar to `Enumerable#count`
+- Alias `Mapper#find_all` to `Mapper#select`
+- Alias `Mapper#detect` to `Mapper#find`
+- Add `Mapper#reject` method to negate queries
+- Allow `Mapper#find` to take a block like `Mapper#select`
+- Add atomic incrementation
+
 ## Version 0.4.8
 
 - Provide configuration one-liner ability for simple configs

data/README.md

@@ -4,8 +4,6 @@ Perpetuity is a simple Ruby object persistence layer that attempts to follow Mar
 
 Your objects will hopefully eventually be able to be persisted into whichever database you like. Right now, only MongoDB is supported. Other persistence solutions will come later.
 
-This gem was inspired by [a blog post by Steve Klabnik](http://blog.steveklabnik.com/posts/2011-12-30-active-record-considered-harmful).
-
 ## How it works
 
 In the Data Mapper pattern, the objects you work with don't understand how to persist themselves. They interact with other objects just as in any other object-oriented application, leaving all persistence logic to mapper objects. This decouples them from the database and allows you to write your code without it in mind.
@@ -20,20 +18,16 @@ gem 'perpetuity'
 
 ## Configuration
 
-The only currently supported persistence method is MongoDB. Other schemaless solutions can probably be implemented easily.
+The only currently supported persistence method is MongoDB. Other schemaless solutions can probably be implemented easily. The simplest configuration is with the following line:
 
 ```ruby
-mongodb = Perpetuity::MongoDB.new(
-  db: 'example_db',            # Required
-  host: 'mongodb.example.com', # Default: 'localhost'
-  port: 27017,                 # Default: 27017
-  username: 'mongo',           # If no username/password given, do not authenticate
-  password: 'password'
-)
+Perpetuity.data_source :mongodb, 'my_database'
+```
 
-Perpetuity.configure do 
-  data_source mongodb
-end
+If your database is on another server or you need authentication, you can specify those as options:
+
+```ruby
+Perpetuity.data_source :mongodb, 'my_database', host: 'mongo.example.com', port: 27017, username: 'mongo', password: 'password'
 ```
 
 ## Setting up object mappers
@@ -112,7 +106,7 @@ Notice that we have to use a single `&` and surround each criterion with parenth
 
 ## Associations with Other Objects
 
-The database can natively serialize some objects. For example, MongoDB can serialize `String`, `Numeric`, `Array`, `Hash`, `Time`, `nil`, `true`, `false`, and a few others. For other data types, you must determine whether you want those attributes embedded within the same document in the database or attached as a reference. For example, a `Post` could have `Comment`s, which would likely be embedded within the post object. But these comments could have an `author` attribute that references the `Person` that wrote the comment. Embedding the author in this case is not a good idea since it would be a duplicate of the `Person` that wrote it, which would then be out of sync if the original object is modified.
+The database can natively serialize some objects. For example, MongoDB can serialize `String`, `Numeric`, `Array`, `Hash`, `Time`, `nil`, `true`, `false`, and a few others. For other objects, you must determine whether you want those attributes embedded within the same document in the database or attached as a reference. For example, a `Post` could have `Comment`s, which would likely be embedded within the post object. But these comments could have an `author` attribute that references the `Person` that wrote the comment. Embedding the author in this case is not a good idea since it would be a duplicate of the `Person` that wrote it, which would then be out of sync if the original object is modified.
 
 If an object references another type of object, the association is declared just as any other attribute. No special treatment is required. For embedded relationships, make sure you use the `embedded: true` option in the attribute.
 
@@ -158,6 +152,8 @@ article_mapper.load_association! articles, :author     # All author objects for
 article_mapper.load_association! articles, :tags       # M:N
 ```
 
+Each of these `load_association!` calls will only execute the number of queries necessary to retrieve all of the objects. For example, if the `author` attribute for the selected articles contains both `User` and `Admin` objects, it will execute two queries (one each for `User` and `Admin`). If the tags for all of the selected articles are all `Tag` objects, only one query will be executed even in the M:N case.
+
 ## Customizing persistence
 
 Setting the ID of a record to a custom value rather than using the DB default.
@@ -212,6 +208,8 @@ end
 Perpetuity[Article].reindex!
 ```
 
+You could put this in a rake task to be executed when you deploy your app.
+
 ## Contributing
 
-Right now, this code is pretty bare and there are possibly some design decisions that need some more refinement. You can help. If you have ideas to build on this, send some love in the form of pull requests or issues or [tweets](http://twitter.com/jamie_gaskins) or e-mails and I'll do what I can for them.
+There are plenty of opportunities to improve what's here and possibly some design decisions that need some more refinement. You can help. If you have ideas to build on this, send some love in the form of pull requests, issues or [tweets](http://twitter.com/jamie_gaskins) and I'll do what I can for them.

data/lib/perpetuity/dereferencer.rb

@@ -35,9 +35,16 @@ module Perpetuity
     end
 
     def objects klass, ids
-      mapper_registry[klass].select { |object|
-        object.id.in ids.uniq
-      }.to_a
+      ids = ids.uniq
+      if ids.one?
+        mapper_registry[klass].find(ids.first)
+      elsif ids.none?
+        []
+      else
+        mapper_registry[klass].select { |object|
+          object.id.in ids.uniq
+        }.to_a
+      end
     end
 
     def referenceable? ref

data/lib/perpetuity/mapper.rb

@@ -72,8 +72,24 @@ module Perpetuity
       configuration.data_source
     end
 
-    def count
-      data_source.count mapped_class
+    def count &block
+      data_source.count mapped_class, &block
+    end
+
+    def any? &block
+      count(&block) > 0
+    end
+
+    def all? &block
+      count(&block) == count
+    end
+
+    def one? &block
+      count(&block) == 1
+    end
+
+    def none? &block
+      !any?(&block)
     end
 
     def first
@@ -85,12 +101,24 @@ module Perpetuity
     end
 
     def select &block
-      query = data_source.query(&block).to_db
-      retrieve query
+      retrieve data_source.query(&block).to_db
     end
 
-    def find id
-      select { |object| object.id == id }.first
+    alias :find_all :select
+
+    def find *args, &block
+      if block_given?
+        select(&block).first
+      else
+        id = args.first
+        select { |object| object.id == id }.first
+      end
+    end
+
+    alias :detect :find
+
+    def reject &block
+      retrieve data_source.negate_query(&block).to_db
     end
 
     def delete object
@@ -134,6 +162,18 @@ module Perpetuity
       update object, serialize(object), false
     end
 
+    def increment object, attribute, count=1
+      data_source.increment mapped_class, object.id, attribute, count
+    rescue Moped::Errors::OperationFailure
+      raise ArgumentError.new('Attempted to increment a non-numeric value')
+    end
+
+    def decrement object, attribute, count=1
+      data_source.increment mapped_class, object.id, attribute, -count
+    rescue Moped::Errors::OperationFailure
+      raise ArgumentError.new('Attempted to decrement a non-numeric value')
+    end
+
     def self.validate &block
       validations.instance_exec(&block)
     end

data/lib/perpetuity/mongodb/query.rb

@@ -11,6 +11,10 @@ module Perpetuity
         @query.to_db
       end
 
+      def negate
+        @query.negate
+      end
+
       def method_missing missing_method
         QueryAttribute.new missing_method
       end

data/lib/perpetuity/mongodb/query_attribute.rb

@@ -45,6 +45,18 @@ module Perpetuity
       def to_sym
         name
       end
+
+      def method_missing name
+        if name.to_s == 'id'
+          name = :"#{self.name}.__metadata__.#{name}"
+        elsif name.to_s == 'klass'
+          name = :"#{self.name}.__metadata__.class"
+        else
+          name = :"#{self.name}.#{name}"
+        end
+
+        self.class.new(name)
+      end
     end
   end
 end

data/lib/perpetuity/mongodb/query_expression.rb

@@ -4,26 +4,37 @@ require 'perpetuity/mongodb/query_intersection'
 module Perpetuity
   class MongoDB
     class QueryExpression
-      attr_accessor :comparator
+      attr_accessor :comparator, :negated
 
       def initialize attribute, comparator, value
         @attribute = attribute
         @comparator = comparator
         @value = value
+        @negated = false
 
         @attribute = @attribute.to_sym if @attribute.respond_to? :to_sym
       end
 
       def to_db
-        send @comparator
+        public_send @comparator
       end
 
       def equals
-        { @attribute => @value }
+        if @negated
+          { @attribute => { '$ne' => @value } }
+        else
+          { @attribute => @value }
+        end
       end
 
       def function func
-        { @attribute => { func => @value } }
+        f = { func => @value }
+
+        if @negated
+          { @attribute => { '$not' => f } }
+        else
+          { @attribute => f }
+        end
       end
 
       def less_than
@@ -51,7 +62,11 @@ module Perpetuity
       end
 
       def matches
-        { @attribute => @value }
+        if @negated
+          { @attribute => { '$not' => @value } }
+        else
+          { @attribute => @value }
+        end
       end
 
       def | other
@@ -61,6 +76,12 @@ module Perpetuity
       def & other
         QueryIntersection.new(self, other)
       end
+
+      def negate
+        expr = dup
+        expr.negated = true
+        expr
+      end
     end
   end
 end

data/lib/perpetuity/mongodb.rb

@@ -59,9 +59,9 @@ module Perpetuity
       end
     end
 
-    def count klass, criteria={}, options={}
-      criteria = to_bson_id(criteria)
-      collection(klass).find(criteria).count
+    def count klass, criteria={}, &block
+      q = block_given? ? query(&block).to_db : criteria
+      collection(klass).find(q).count
     end
 
     def delete_all klass
@@ -92,8 +92,23 @@ module Perpetuity
       end
     end
 
+    def increment klass, id, attribute, count=1
+      find(klass, id).update '$inc' => { attribute => count }
+    end
+
+    def find klass, id
+      collection(klass).find(to_bson_id(_id: id))
+    end
+
     def to_bson_id criteria
       criteria = criteria.dup
+
+      # Check for both string and symbol ID in criteria
+      if criteria.has_key?('id')
+        criteria['_id'] = Moped::BSON::ObjectId(criteria['id']) rescue criteria['id']
+        criteria.delete 'id'
+      end
+
       if criteria.has_key?(:id)
         criteria[:_id] = Moped::BSON::ObjectId(criteria[:id]) rescue criteria[:id]
         criteria.delete :id
@@ -122,7 +137,7 @@ module Perpetuity
     end
 
     def update klass, id, new_data
-      collection(klass).find({ _id: id }).update(new_data)
+      find(klass, id).update(new_data)
     end
 
     def can_serialize? value
@@ -137,6 +152,10 @@ module Perpetuity
       Query.new(&block)
     end
 
+    def negate_query &block
+      Query.new(&block).negate
+    end
+
     def index klass, attribute, options={}
       @indexes[klass] ||= Set.new
 

data/lib/perpetuity/retrieval.rb

@@ -49,7 +49,7 @@ module Perpetuity
     end
 
     def count
-      @data_source.count(@class, @criteria, options)
+      @data_source.count(@class, @criteria)
     end
 
     def options

data/lib/perpetuity/version.rb

@@ -1,3 +1,3 @@
 module Perpetuity
-  VERSION = "0.4.8"
+  VERSION = "0.5.0"
 end

data/lib/perpetuity.rb

@@ -17,7 +17,7 @@ module Perpetuity
   def self.generate_mapper_for klass, &block
     mapper = Class.new(Mapper)
     mapper.map klass, mapper_registry
-    mapper.instance_exec(&block) if block_given?
+    mapper.class_eval(&block) if block_given?
   end
 
   def self.[] klass

data/spec/integration/enumerable_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'support/test_classes'
+
+describe 'enumerable syntax' do
+  let(:mapper) { Perpetuity[Article] }
+
+  let(:current_time) { Time.now }
+  let(:foo) { Article.new("Foo #{Time.now.to_f}", '', nil, current_time - 60) }
+  let(:bar) { Article.new("Bar #{Time.now.to_f}", '', nil, current_time + 60) }
+
+  before do
+    mapper.insert foo
+  end
+
+  it 'finds a single object based on criteria' do
+    mapper.find { |a| a.title == foo.title }.should be == foo
+  end
+
+  context 'excludes objects based on criteria' do
+    before do
+      mapper.insert bar
+    end
+
+    it 'excludes on equality' do
+      articles = mapper.reject { |a| a.title == bar.title }.to_a
+      articles.should include foo
+      articles.should_not include bar
+    end
+
+    it 'excludes on inequality' do
+      articles = mapper.reject { |a| a.published_at <= current_time }.to_a
+      articles.should include bar
+      articles.should_not include foo
+    end
+
+    it 'excludes on not-equal' do
+      articles = mapper.reject { |a| a.title != foo.title }.to_a
+      articles.should include foo
+      articles.should_not include bar
+    end
+
+    it 'excludes on regex match' do
+      articles = mapper.reject { |a| a.title =~ /Foo/ }.to_a
+      articles.should include bar
+      articles.should_not include foo
+    end
+  end
+end

data/spec/integration/mongodb_spec.rb

@@ -62,11 +62,11 @@ module Perpetuity
       mongo.count(klass).should == 3
     end
 
-    it 'counts documents matching criteria' do
+    it 'counts the documents matching a query' do
       mongo.delete_all klass
+      1.times { mongo.insert klass, { name: 'bar' } }
       3.times { mongo.insert klass, { name: 'foo' } }
-      3.times { mongo.insert klass, { name: 'bar' } }
-      mongo.count(klass, name: 'foo').should == 3
+      mongo.count(klass) { |o| o.name == 'foo' }.should == 3
     end
 
     it 'gets the first document in a collection' do
@@ -139,6 +139,19 @@ module Perpetuity
       end
     end
 
+    describe 'atomic operations' do
+      after(:all) { mongo.delete_all klass }
+
+      it 'increments the value of an attribute' do
+        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
+        mongo.increment klass, id, :count, -1
+        mongo.retrieve(klass, id: id).first['count'].should == 11
+      end
+    end
+
     describe 'operation errors' do
       let(:data) { { foo: 'bar' } }
       let(:index) { mongo.index Object, :foo, unique: true }

data/spec/integration/retrieval_spec.rb

@@ -7,7 +7,7 @@ describe "retrieval" do
 
   it "gets all the objects of a class" do
     expect { mapper.insert Article.new }.
-      to change { mapper.all.count }.by 1
+      to change { mapper.all.to_a.count }.by 1
   end
 
   it "has an ID when retrieved" do
@@ -51,6 +51,13 @@ describe "retrieval" do
     mapper.all.limit(4).to_a.should have(4).items
   end
 
+  it 'counts result set' do
+    title = "Foo #{Time.now.to_f}"
+    mapper = Perpetuity[Article]
+    5.times { mapper.insert Article.new(title) }
+    mapper.count { |article| article.title == title }.should == 5
+  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 }
@@ -118,7 +125,7 @@ describe "retrieval" do
   describe 'counting results' do
     let(:title) { SecureRandom.hex }
     let(:articles) do
-      5.times.map { Article.new(title) } + 5.times.map { Article.new }
+      2.times.map { Article.new(title) } + 2.times.map { Article.new }
     end
 
     before do
@@ -127,7 +134,32 @@ describe "retrieval" do
 
     it 'counts the results' do
       query = mapper.select { |article| article.title == title }
-      query.count.should == 5
+      query.count.should == 2
+    end
+
+    it 'checks whether any results match' do
+      mapper.any? { |article| article.title == title }.should be_true
+      mapper.any? { |article| article.title == SecureRandom.hex }.should be_false
+    end
+
+    it 'checks whether all results match' do
+      mapper.delete_all
+      2.times { |i| mapper.insert Article.new(title, nil, nil, nil, i) }
+      mapper.all? { |article| article.title == title }.should be_true
+      mapper.all? { |article| article.views == 0 }.should be_false
+    end
+
+    it 'checks whether only one result matches' do
+      unique_title = SecureRandom.hex
+      mapper.insert Article.new(unique_title)
+      mapper.one? { |article| article.title == unique_title }.should be_true
+      mapper.one? { |article| article.title == title }.should be_false
+      mapper.one? { |article| article.title == 'Title' }.should be_false
+    end
+
+    it 'checks whether no results match' do
+      mapper.none? { |article| article.title == SecureRandom.hex }.should be_true
+      mapper.none? { |article| article.title == title }.should be_false
     end
   end
 
@@ -144,4 +176,11 @@ describe "retrieval" do
       retrieved_article.author.should be_a CRM::Person
     end
   end
+
+  it 'selects objects with nested data' do
+    user = User.new(first_name: 'foo', last_name: 'bar')
+    mapper = Perpetuity[User]
+    mapper.insert user
+    mapper.select { |user| user.name.first_name == 'foo' }.map(&:id).should include user.id
+  end
 end

data/spec/integration/update_spec.rb

@@ -56,6 +56,37 @@ describe 'updating' do
     retrieved_authors.map(&:klass).should == [User, User]
     retrieved_authors.map(&:id).should == [dave.id, andy.id]
   end
+
+  describe 'atomic increments/decrements' do
+    let(:view_count) { 0 }
+    let(:article) { Article.new('title', 'body', nil, nil, view_count) }
+
+    it 'increments attributes of objects in the database' do
+      mapper.increment article, :views
+      mapper.increment article, :views, 10
+      mapper.find(article.id).views.should == view_count + 11
+    end
+
+    it 'decrements attributes of objects in the database' do
+      mapper.decrement article, :views
+      mapper.decrement article, :views, 10
+      mapper.find(article.id).views.should == view_count - 11
+    end
+
+    context 'with an object with the specified attribute missing' do
+      let(:article) { Article.new('title', 'body', nil, nil, nil) }
+
+      it 'raises an exception when incrementing' do
+        expect { mapper.increment article, :views }.to raise_error(
+          ArgumentError, 'Attempted to increment a non-numeric value')
+      end
+
+      it 'raises an exception when decrementing' do
+        expect { mapper.decrement article, :views }.to raise_error(
+          ArgumentError, 'Attempted to decrement a non-numeric value')
+      end
+    end
+  end
 end
 
 

data/spec/perpetuity/dereferencer_spec.rb

@@ -5,19 +5,40 @@ module Perpetuity
   describe Dereferencer do
     let(:registry) { double('Mapper Registry') }
     let(:mapper) { double('ObjectMapper') }
-    let(:object) { double('Object', id: 1, class: Object) }
-    let(:reference) { Reference.new(Object, 1) }
-    let(:objects) { [object] }
+    let(:first) { double('Object', id: 1, class: Object) }
+    let(:second) { double('Object', id: 2, class: Object) }
+    let(:first_ref) { Reference.new(Object, 1) }
+    let(:second_ref) { Reference.new(Object, 2) }
+    let(:objects) { [first, second] }
+    let(:derefer) { Dereferencer.new(registry) }
 
-    before do
-      registry.should_receive(:[]).with(Object) { mapper }
-      mapper.should_receive(:select) { objects }
+    context 'with one reference' do
+      before do
+        registry.should_receive(:[]).with(Object) { mapper }
+        mapper.should_receive(:find).with(1) { first }
+      end
+
+      it 'loads objects based on the specified objects and attribute' do
+        derefer.load first_ref
+        derefer[first_ref].should == first
+      end
+    end
+
+    context 'with no references' do
+      it 'returns an empty array' do
+        derefer.load(nil).should == []
+      end
     end
 
-    it 'loads objects based on the specified objects and attribute' do
-      derefer = Dereferencer.new(registry)
-      derefer.load reference
-      derefer[reference].should == object
+    context 'with multiple references' do
+      before do
+        registry.should_receive(:[]).with(Object) { mapper }
+        mapper.should_receive(:select) { objects }
+      end
+
+      it 'returns the array of dereferenced objects' do
+        derefer.load([first_ref, second_ref]).should == objects
+      end
     end
   end
 end

data/spec/perpetuity/mapper_spec.rb

@@ -59,14 +59,34 @@ module Perpetuity
         mapper.count.should be == 4
       end
 
-      it 'finds an object by ID' do
-        returned_object = double('Retrieved Object')
-        criteria = { id: 1 }
-        options = {:attribute=>nil, :direction=>nil, :limit=>nil, :page=>nil}
-        data_source.should_receive(:retrieve)
-                   .with(Object, criteria, options) { [returned_object] }
-
-        mapper.find(1).should be == returned_object
+      describe 'finding a single object' do
+        let(:options) { {:attribute=>nil, :direction=>nil, :limit=>nil, :page=>nil} }
+        let(:returned_object) { double('Retrieved Object') }
+
+        it 'finds an object by ID' do
+          criteria = { id: 1 }
+          data_source.should_receive(:retrieve)
+                     .with(Object, criteria, options) { [returned_object] }
+
+          mapper.find(1).should be == returned_object
+        end
+
+        it 'finds multiple objects with a block' do
+          criteria = { name: 'foo' }
+          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]
+        end
+
+        it 'finds an object with a block' do
+          criteria = { 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
+        end
       end
 
       it 'saves an object' do

data/spec/perpetuity/mongodb/query_attribute_spec.rb

@@ -7,6 +7,18 @@ module Perpetuity
 
     its(:name) { should == :attribute_name }
 
+    it 'allows checking subattributes' do
+      attribute.title.name.should == :'attribute_name.title'
+    end
+
+    it 'wraps .id subattribute in metadata' do
+      attribute.id.name.should == :'attribute_name.__metadata__.id'
+    end
+
+    it 'wraps .klass subattribute in metadata' do
+      attribute.klass.name.should == :'attribute_name.__metadata__.class'
+    end
+
     it 'checks for equality' do
       (attribute == 1).should be_a MongoDB::QueryExpression
     end

data/spec/perpetuity/mongodb/query_spec.rb

@@ -33,5 +33,47 @@ module Perpetuity
     it 'generates Mongo regexp expressions' do
       query.new{ |user| user.name =~ /Jamie/ }.to_db.should == {name: /Jamie/}
     end
+
+    describe 'negated queries' do
+      it 'negates an equality query' do
+        q = query.new { |user| user.name == 'Jamie' }
+        q.negate.to_db.should == { name: { '$ne' => 'Jamie' } }
+      end
+
+      it 'negates a not-equal query' do
+        q = query.new { |account| account.balance != 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$ne' => 10 } } }
+      end
+
+      it 'negates a less-than query' do
+        q = query.new { |account| account.balance < 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$lt' => 10 } } }
+      end
+
+      it 'negates a less-than-or-equal query' do
+        q = query.new { |account| account.balance <= 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$lte' => 10 } } }
+      end
+
+      it 'negates a greater-than query' do
+        q = query.new { |account| account.balance > 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$gt' => 10 } } }
+      end
+
+      it 'negates a greater-than-or-equal query' do
+        q = query.new { |account| account.balance >= 10 }
+        q.negate.to_db.should == { balance: { '$not' => { '$gte' => 10 } } }
+      end
+
+      it 'negates a regex query' do
+        q = query.new { |account| account.name =~ /Jamie/ }
+        q.negate.to_db.should == { name: { '$not' => /Jamie/ } }
+      end
+
+      it 'negates a inclusion query' do
+        q = query.new { |article| article.tags.in ['tag1', 'tag2'] }
+        q.negate.to_db.should == { tags: { '$not' => { '$in' => ['tag1', 'tag2'] } } }
+      end
+    end
   end
 end

data/spec/support/test_classes/article.rb

@@ -8,4 +8,9 @@ class Article
     @published_at = published_at
     @views = views
   end
+
+  def == other
+    title == other.title &&
+    body == other.body
+  end
 end

data/spec/support/test_classes.rb

@@ -2,12 +2,12 @@
   require "support/test_classes/#{file}"
 end
 
-Perpetuity.generate_mapper_for User do
+class UserMapper < Perpetuity::Mapper
+  map User
   attribute :name
 end
 
-class ArticleMapper < Perpetuity::Mapper
-  map Article
+Perpetuity.generate_mapper_for Article do
   attribute :title
   attribute :body
   attribute :author

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: perpetuity
 version: !ruby/object:Gem::Version
-  version: 0.4.8
-  prerelease: 
+  version: 0.5.0
 platform: ruby
 authors:
 - Jamie Gaskins
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-07 00:00:00.000000000 Z
+date: 2013-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -30,7 +27,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -38,7 +34,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -46,7 +41,6 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: moped
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -54,7 +48,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -103,6 +96,7 @@ files:
 - perpetuity.gemspec
 - spec/integration/associations_spec.rb
 - spec/integration/deletion_spec.rb
+- spec/integration/enumerable_spec.rb
 - spec/integration/indexing_spec.rb
 - spec/integration/mongodb_spec.rb
 - spec/integration/pagination_spec.rb
@@ -146,37 +140,31 @@ files:
 - spec/support/test_classes/user.rb
 homepage: https://github.com/jgaskins/perpetuity.git
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -66928365718597043
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -66928365718597043
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.25
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Persistence library allowing serialization of Ruby objects
 test_files:
 - spec/integration/associations_spec.rb
 - spec/integration/deletion_spec.rb
+- spec/integration/enumerable_spec.rb
 - spec/integration/indexing_spec.rb
 - spec/integration/mongodb_spec.rb
 - spec/integration/pagination_spec.rb