perpetuity 0.3.1 → 0.4

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## Version 0.4
+
+- Mapper select DSL now more closely resembles `Enumerable` syntax
+  - Instead of `mapper.select { published_at < Time.now }` you would write `mapper.select { |article| article.published_at < Time.now }`
+  - It's a little more typing, but it eliminates a lot of problems that came from calling instance_exec on the block. It meant we couldn't call methods on the current object (they would be invoked on the `Query` object) or use instance variables from the current object.
+  - Explained more in [issue #19](https://github.com/jgaskins/perpetuity/issues/19)
+
+## Version 0.3.1
+
+- Access object state via instance methods to store actual object state, rather than treating all objects as value objects
+- Use `Object.allocate` rather than `Object.new` when restoring state to an object from the database
+
 ## Version 0.3
 
 - Use `Perpetuity[]` instead of `Perpetuity::Mapper[]` to get mapper instances

data/README.md

@@ -72,18 +72,16 @@ You can load specific objects by calling the `find` method with an ID param on t
 
 ```ruby
 article  = Perpetuity[Article].find params[:id]
-users    = Perpetuity[User].select { email == 'me@example.com' }
-articles = Perpetuity[Article].select { published_at < Time.now }
-comments = Perpetuity[Comment].select { article_id.in articles.map(&:id) }
+users    = Perpetuity[User].select { |user| user.email == 'me@example.com' }
+articles = Perpetuity[Article].select { |article| article.published_at < Time.now }
+comments = Perpetuity[Comment].select { |comment| comment.article_id.in articles.map(&:id) }
 ```
 
-Unfortunately, due to limitations in the Ruby language itself, this is as close as I could get to a true `Enumerable`-style select method. Once I can override `&&` and `||`, we can put more Rubyesque code in here.
-
 These methods will return a Perpetuity::Retrieval object, which will lazily retrieve the objects from the database. They will wait to hit the DB when you begin iterating over the objects so you can continue chaining methods.
 
 ```ruby
 article_mapper = Perpetuity[Article]
-articles = article_mapper.select { published_at < Time.now }
+articles = article_mapper.select { |article| article.published_at < Time.now }
 articles = articles.sort(:published_at).reverse
 articles = articles.page(2).per_page(10) # built-in pagination
 
@@ -92,6 +90,14 @@ articles.each do |article| # This is when the DB gets hit
 end
 ```
 
+Unfortunately, due to limitations in the Ruby language itself, we cannot get a true `Enumerable`-style select method. The limitation shows itself when needing to have multiple criteria for a query, as in this super-secure example:
+
+```ruby
+user = Perpetuity[User].select { |user| (user.email == params[:email]) & (user.password == params[:password]) }
+```
+
+Notice that we have to use a single `&` and surround each criterion with parentheses. If we could override `&&` and `||`, we could put more Rubyesque code in here, but until then, we have to operate within the boundaries of the operators that can be overridden.
+
 ## 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. If an object references another type of object (such as an article referencing its author, a `User` object), the association is declared just as any other attribute. No special treatment is required.

data/lib/perpetuity/mongodb/query.rb

@@ -4,7 +4,7 @@ module Perpetuity
   class MongoDB
     class Query
       def initialize &block
-        @query = instance_exec(&block)
+        @query = block.call(self)
       end
 
       def to_db

data/lib/perpetuity/version.rb

@@ -1,3 +1,3 @@
 module Perpetuity
-  VERSION = "0.3.1"
+  VERSION = "0.4"
 end

data/spec/perpetuity/mongodb/query_spec.rb

@@ -5,33 +5,33 @@ module Perpetuity
     let(:query) { MongoDB::Query }
 
     it 'generates Mongo equality expressions' do
-      query.new{name == 'Jamie'}.to_db.should == {name: 'Jamie'}
+      query.new{ |user| user.name == 'Jamie' }.to_db.should == {name: 'Jamie'}
     end
 
     it 'generates Mongo less-than expressions' do
-      query.new{quantity < 10}.to_db.should == {quantity: { '$lt' => 10}}
+      query.new{ |v| v.quantity < 10 }.to_db.should == {quantity: { '$lt' => 10}}
     end
 
     it 'generates Mongo less-than-or-equal expressions' do
-      query.new{quantity <= 10}.to_db.should == {quantity: { '$lte' => 10}}
+      query.new{ |v| v.quantity <= 10 }.to_db.should == {quantity: { '$lte' => 10}}
     end
 
     it 'generates Mongo greater-than expressions' do
-      query.new{quantity > 10}.to_db.should == {quantity: { '$gt' => 10}}
+      query.new{ |v| v.quantity > 10 }.to_db.should == {quantity: { '$gt' => 10}}
     end
 
     it 'generates Mongo greater-than-or-equal expressions' do
-      query.new{quantity >= 10}.to_db.should == {quantity: { '$gte' => 10}}
+      query.new{ |v| v.quantity >= 10 }.to_db.should == {quantity: { '$gte' => 10}}
     end
 
     it 'generates Mongo inequality expressions' do
-      query.new{name.not_equal? 'Jamie'}.to_db.should == {
+      query.new{ |user| user.name.not_equal? 'Jamie' }.to_db.should == {
         name: {'$ne' => 'Jamie'}
       }
     end
 
     it 'generates Mongo regexp expressions' do
-      query.new{name =~ /Jamie/}.to_db.should == {name: /Jamie/}
+      query.new{ |user| user.name =~ /Jamie/ }.to_db.should == {name: /Jamie/}
     end
   end
 end

data/spec/perpetuity_spec.rb

@@ -163,55 +163,55 @@ describe Perpetuity do
       end
 
       it 'selects objects using equality' do
-        selected = Perpetuity[Article].select { title == 'Published' }
+        selected = Perpetuity[Article].select { |article| article.title == 'Published' }
         selected.map(&:id).should include published.id
         selected.map(&:id).should_not include draft.id
       end
 
       it 'selects objects using greater-than' do
-        selected = Perpetuity[Article].select { published_at < Time.now }
+        selected = Perpetuity[Article].select { |article| article.published_at < Time.now }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id
       end
 
       it 'selects objects using greater-than-or-equal' do
-        selected = Perpetuity[Article].select { views >= 3 }
+        selected = Perpetuity[Article].select { |article| article.views >= 3 }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id
       end
 
       it 'selects objects using less-than' do
-        selected = Perpetuity[Article].select { views < 3 }
+        selected = Perpetuity[Article].select { |article| article.views < 3 }
         ids = selected.map(&:id)
         ids.should include draft.id
         ids.should_not include published.id
       end
 
       it 'selects objects using less-than-or-equal' do
-        selected = Perpetuity[Article].select { views <= 0 }
+        selected = Perpetuity[Article].select { |article| article.views <= 0 }
         ids = selected.map(&:id)
         ids.should include draft.id
         ids.should_not include published.id
       end
 
       it 'selects objects using inequality' do
-        selected = Perpetuity[Article].select { title.not_equal? 'Draft' }
+        selected = Perpetuity[Article].select { |article| article.title.not_equal? 'Draft' }
         ids = selected.map(&:id)
         ids.should_not include draft.id
         ids.should include published.id
       end
 
       it 'selects objects using regular expressions' do
-        selected = Perpetuity[Article].select { title =~ /Pub/ }
+        selected = Perpetuity[Article].select { |article| article.title =~ /Pub/ }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id
       end
 
       it 'selects objects using inclusion' do
-        selected = Perpetuity[Article].select { title.in %w( Published ) }
+        selected = Perpetuity[Article].select { |article| article.title.in %w( Published ) }
         ids = selected.map(&:id)
         ids.should include published.id
         ids.should_not include draft.id

data/spec/test_classes.rb

@@ -31,11 +31,13 @@ class ArticleMapper < Perpetuity::Mapper
   attribute :views
 
   def published
-    select { (published_at.not_equal? nil) & (published_at < Time.now) }
+    select { |article| (article.published_at.not_equal? nil) &
+                       (article.published_at < Time.now) }
   end
 
   def unpublished
-    select { (published_at == nil) | (published_at > Time.now) }
+    select { |article| (article.published_at == nil) |
+                       (article.published_at > Time.now) }
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: perpetuity
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: '0.4'
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-02 00:00:00.000000000 Z
+date: 2013-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake