mongoid-mirrored 0.0.2 → 0.0.3

data/README.md

@@ -122,8 +122,31 @@ Known issues
 
 Performance
 ------------
-
-perf/performance.rb
+I ran a [benchmark](https://github.com/angelim/mongoid-mirrored/blob/master/perf/benchmark.rb) on my computer with the following results
+
+Benchmark for referenced documents
+
+	                                                                     user     system      total        real
+	creating 10000 comments in 200 posts from root collection       7.820000   0.250000   8.070000   (8.252877)
+	updating 10000 comments from root collection                    5.080000   0.250000   5.330000   (5.583467)
+	# traversing posts with comments 10000 times                    0.670000   0.010000   0.680000   (0.772653)
+	finding posts from the 1000 newest comments                     0.530000   0.040000   0.570000   (0.647710)
+	deleting 10000 comments from root collection                    2.710000   0.180000   2.890000   (3.238750)
+	creating 10000 comments in 200 posts from embedding collection  8.270000   0.210000   8.480000   (8.530049)
+	updating 10000 comments from embedding collection               9.830000   0.360000  10.190000   (10.76156)
+	deleting 10000 comments from embedding collection               4.750000   0.240000   4.990000   (5.217647)
+
+Benchmark for mirrored documents
+
+	                                                                      user     system      total        real
+	creating 10000 comments in 200 posts from root collection       14.870000    0.450000  15.320000  (15.476777)
+	updating 10000 comments from root collection                    25.590000    0.970000  26.560000  (36.910317)
+	# traversing posts with comments 10000 times                    0.200000     0.000000   0.200000   (0.211826)
+	finding posts from the 1000 newest comments                     0.190000   0.000000   0.190000     (0.198631)
+	deleting 10000 comments from root collection                    17.880000    0.820000  18.700000  (21.626592)
+	creating 10000 comments in 200 posts from embedding collection  7.100000     0.340000   7.440000  ( 8.562442)
+	updating 10000 comments from embedding collection               5.030000     0.300000   5.330000  ( 6.058490)
+	deleting 10000 comments from embedding collection               2.540000     0.130000   2.670000  ( 2.733644)
 
 Credits
 -------

data/lib/mongoid-mirrored/helper_methods.rb

@@ -3,7 +3,7 @@ module Mongoid
     module HelperMethods
       def extract_options(*args)
         options = args.extract_options!
-        self.embedding_models = args
+        self.embedding_models = {:all => args, :current => nil}
         self.embedding_options = options
         
         # set defaults
@@ -24,13 +24,13 @@ module Mongoid
         inverse_of
       end
       
-      def embedding_klass(embedding_sym)
+      def symbol_to_class(symbol)
         begin
-          _embedding_klass = embedding_sym.to_s.classify.constantize 
+          symbol.to_s.classify.constantize 
         rescue
-          Object.const_set embedding_sym.to_s.classify, Class.new 
+          Object.const_set symbol.to_s.classify, Class.new 
         ensure
-          _embedding_klass = embedding_sym.to_s.classify.constantize 
+          symbol.to_s.classify.constantize 
         end
       end
     end

data/lib/mongoid-mirrored/mirror/mirror_methods.rb

@@ -2,35 +2,54 @@ module Mongoid
   module Mirrored
     module MirrorMethods
       
-      def embeds_mirror_in(_embedding_model, mirror_klass)
+      def define_mirror_attributes
+        mirror_klass.class_eval <<-EOF
+          cattr_accessor :mirror_attributes
+          self.mirror_attributes = {
+                                    :root => {:association => :#{root_association}, :klass => #{self}},
+                                    :embedding => {
+                                                   :sym => :#{embedding_models[:current]}, 
+                                                   :id => :#{embedding_models[:current]}_id,
+                                                   :instance => "#{embedding_models[:current]}",
+                                                   :klass => #{symbol_to_class(embedding_models[:current])},
+                                                   :models => #{embedding_models[:all]}
+                                                   }
+                                    }
+          EOF
+      end
+      
+      def embeds_mirror
         # mongoid macro embedded_in
         # eg: embedded_in :post, :inverse_of => :comments
         
         mirror_klass.class_eval <<-EOT
-          embedded_in :#{_embedding_model}, :inverse_of => :#{root_association}
+          embedded_in mirror_attributes[:embedding][:sym], :inverse_of => mirror_attributes[:root][:association]
         EOT
       end
       
-      def define_after_create_callback(_embedding_model, mirror_klass)
+      def define_after_create_callback
         unless mirror_klass.instance_methods.include?(:_create_root)
           mirror_klass.class_eval <<-EOF
             after_create  :_create_root
           EOF
         end
 
+        # Comment.collection.insert(attributes.merge(:post_id => post.id))
         mirror_klass.class_eval <<-EOF
           def _create_root
-            #{@root_klass}.collection.insert(attributes.merge(:#{_embedding_model}_id => #{_embedding_model}.id))
+            mirror_attributes[:root][:klass].collection.insert(attributes.merge(mirror_attributes[:embedding][:id] => eval(mirror_attributes[:embedding][:instance]).id))
           end
         EOF
       end
-      def define_after_update_callback(_embedding_model, mirror_klass)
+      
+      def define_after_update_callback
         unless mirror_klass.instance_methods.include?(:_update_root)
           mirror_klass.class_eval <<-EOF
             after_update  :_update_root
           EOF
         end
-
+        
+        # Comment.collection.update({ :_id => id}, '$set' => attributes.except('_id'))
         mirror_klass.class_eval <<-EOF
            def _update_root
              #{@root_klass}.collection.update({ :_id => id }, '$set' => attributes.except('_id'))
@@ -38,41 +57,48 @@ module Mongoid
          EOF
       end
 
-      def define_after_destroy_callback(_embedding_model, mirror_klass)
+      def define_after_destroy_callback
         unless mirror_klass.instance_methods.include?(:_destroy_root)
           mirror_klass.class_eval <<-EOF
             after_destroy  :_destroy_root
           EOF
         end
 
+        # Comment.collection.remove({ :id => id}, '$set' => attributes)
         mirror_klass.class_eval <<-EOF
            def _destroy_root
-             #{@root_klass}.collection.update({ :_id => id }, '$set' => attributes.except('_id'))
+             #{@root_klass}.collection.remove({ :_id => id })
            end
          EOF
       end
 
-      def define_after_create_siblings(_embedding_model, mirror_klass)
+      def define_after_create_siblings
         unless mirror_klass.instance_methods.include?(:_create_siblings)
           mirror_klass.class_eval <<-EOF
             after_create  :_create_siblings
           EOF
         end
+        
         mirror_klass.class_eval <<-EOF
           def _create_siblings
-            #{embedding_models}.each do |sibling|
+            mirror_attributes[:embedding][:models].each do |sibling|
               _sibling = sibling.to_s
-              next if sibling == :#{_embedding_model}
+              next if sibling == mirror_attributes[:embedding][:sym]
               sibling_klass = sibling.to_s.classify.constantize
               if self[_sibling+"_id"]
-                sibling_klass.collection.update({ :_id => self[_sibling+"_id"] }, '$push' => {:#{root_association} => attributes.merge(:#{_embedding_model}_id => #{_embedding_model}.id)})
+                sibling_klass.collection.update(
+                  { :_id => self[_sibling+"_id"] }, 
+                  '$push' => { 
+                    mirror_attributes[:root][:association] => attributes.merge(mirror_attributes[:embedding][:id] => eval(mirror_attributes[:embedding][:instance]).id)
+                   }
+                )
               end
             end
           end
         EOF
       end
 
-      def define_after_update_siblings(_embedding_model, mirror_klass)
+      def define_after_update_siblings
         unless mirror_klass.instance_methods.include?(:_update_siblings)
           mirror_klass.class_eval <<-EOF
             after_update  :_update_siblings
@@ -80,23 +106,23 @@ module Mongoid
         end
         mirror_klass.class_eval <<-EOF
           def _update_siblings
-            #{embedding_models}.each do |sibling|
+            #{embedding_models[:all]}.each do |sibling|
               _sibling = sibling.to_s
-              next if sibling == :#{_embedding_model}
+              next if sibling == mirror_attributes[:embedding][:sym]
               sibling_klass = sibling.to_s.classify.constantize
               if self[_sibling+"_id"]
                 nested_attr = {}
-                attributes.except("#{_embedding_model}_id").each_pair do |k,v|
-                  nested_attr["#{root_association}.$."+k] = v
+                attributes.except(mirror_attributes[:embedding][:id]).each_pair do |k,v|
+                  nested_attr[mirror_attributes[:root][:association].to_s + ".$." + k] = v
                 end
-                sibling_klass.collection.update({"#{root_association}._id" => id}, '$set' => nested_attr )
+                sibling_klass.collection.update({mirror_attributes[:root][:association].to_s+"._id" => id}, '$set' => nested_attr )
               end
             end
           end
         EOF
       end
 
-      def define_after_destroy_siblings(_embedding_model, mirror_klass)
+      def define_after_destroy_siblings
         unless mirror_klass.instance_methods.include?(:_destroy_siblings)
           mirror_klass.class_eval <<-EOF
             after_destroy  :_destroy_siblings
@@ -104,12 +130,12 @@ module Mongoid
         end
         mirror_klass.class_eval <<-EOF
           def _destroy_siblings
-            #{embedding_models}.each do |sibling|
+            mirror_attributes[:embedding][:models].each do |sibling|
               _sibling = sibling.to_s
-              next if sibling == :#{_embedding_model}
+              next if sibling == mirror_attributes[:embedding][:sym]
               sibling_klass = sibling.to_s.classify.constantize
               if self[_sibling+"_id"]
-                sibling_klass.collection.update({ :_id => self[_sibling+"_id"] }, '$pull' => {:#{root_association} => { :_id => id}})
+                sibling_klass.collection.update({ :_id => self[_sibling+"_id"] }, '$pull' => { mirror_attributes[:root][:association] => { :_id => id}})
               end
             end
           end
@@ -117,26 +143,26 @@ module Mongoid
       end
 
       # Define callbacks for mirror class that don't trigger callbacks on the root class
-      def define_mirror_callbacks_for(_embedding_model, mirror_klass)
+      def define_mirror_callbacks
         if [:both, :from_mirror].include?(embedding_options[:sync_direction])
           if embedding_options[:sync_events].include?(:create) || embedding_options[:sync_events] == [:all]
-            define_after_create_callback(_embedding_model, mirror_klass)
-            if embedding_options[:replicate_to_siblings] && embedding_models.size > 1
-              define_after_create_siblings(_embedding_model, mirror_klass)
+            define_after_create_callback
+            if embedding_options[:replicate_to_siblings] && embedding_models[:all].size > 1
+              define_after_create_siblings
             end
           end
     
           if embedding_options[:sync_events].include?(:update) || embedding_options[:sync_events] == [:all]
-            define_after_update_callback(_embedding_model, mirror_klass)
-            if embedding_options[:replicate_to_siblings] && embedding_models.size > 1
-              define_after_update_siblings(_embedding_model, mirror_klass)
+            define_after_update_callback
+            if embedding_options[:replicate_to_siblings] && embedding_models[:all].size > 1
+              define_after_update_siblings
             end
           end
     
           if embedding_options[:sync_events].include?(:destroy) || embedding_options[:sync_events] == [:all]
-            define_after_destroy_callback(_embedding_model, mirror_klass)
-            if embedding_options[:replicate_to_siblings] && embedding_models.size > 1
-              define_after_destroy_siblings(_embedding_model, mirror_klass)
+            define_after_destroy_callback
+            if embedding_options[:replicate_to_siblings] && embedding_models[:all].size > 1
+              define_after_destroy_siblings
             end
           end
         end

data/lib/mongoid-mirrored/mirrored_in.rb

@@ -8,6 +8,7 @@ module Mongoid
       base.send(:extend, ClassMethods)
       base.send :cattr_accessor, :embedding_models
       base.send :cattr_accessor, :embedding_options
+      base.send :cattr_accessor, :mirror_klass
     end
     
     module ClassMethods
@@ -20,17 +21,19 @@ module Mongoid
         write_fields_with_options { yield }
         @root_klass = self
         # creates a Mirrored class for each embedding model
-        embedding_models.each do |embedding_model|
+        embedding_models[:all].each do |embedding_model|
+          self.embedding_models[:current] = embedding_model
           mirror_klass = Class.new do
             include Mongoid::Document
             
             # includes all fields and methods declared when calling mirrored_in
             class_eval &block
           end
-          
-          define_mirror_callbacks_for(embedding_model, mirror_klass)
-          embeds_mirror_in(embedding_model, mirror_klass)
-          _embedding_klass = embedding_klass(embedding_model)
+          self.mirror_klass = mirror_klass
+          define_mirror_attributes
+          define_mirror_callbacks
+          embeds_mirror
+          _embedding_klass = symbol_to_class(embedding_model)
           
           # Creates the mirrored class Embedding::Root
           _embedding_klass.const_set self.name, mirror_klass

data/lib/mongoid-mirrored/root/root_methods.rb

@@ -28,10 +28,10 @@ module Mongoid
     
           # each embedded class will be touched by the callbacks
           # this should be used with care or write operations could get very slow
-          embedding_models.each do |embedding_model|
+          embedding_models[:all].each do |embedding_model|
             # attributes that will be used to define the root and embedding classes and instances
             embedding_string = embedding_model.to_s
-            _embedding_klass = self.class.embedding_klass(embedding_model)
+            _embedding_klass = self.class.symbol_to_class(embedding_model)
             embedding_instance = eval(embedding_string)
       
             # Only tries to create mirrored document if the embedding instance is given
@@ -52,12 +52,12 @@ module Mongoid
         # if the root document changes the embedding document, the mirrored document is deleted from the previous list
         # and another mirrored document is created for the new embedding document
         define_method :_update_mirrors do
-          embedding_models.each do |embedding_model|
+          embedding_models[:all].each do |embedding_model|
       
             # attributes that will be used to define the root and embedding classes and instances
             embedding_string = embedding_model.to_s
             embedding_instance = eval(embedding_string)
-            _embedding_klass = self.class.embedding_klass(embedding_model)
+            _embedding_klass = self.class.symbol_to_class(embedding_model)
       
             if embedding_instance
               if eval("#{embedding_string}_id_changed?")
@@ -87,11 +87,11 @@ module Mongoid
         # destroys the mirrored document when the destroy method is called on the root document
         # or when the root document establishes a relationship with another embedding document
         define_method :_destroy_mirrors do |changed_embedding_instance = nil|
-          embedding_models.each do |embedding_model|
+          embedding_models[:all].each do |embedding_model|
       
             # attributes that will be used to define the root and embedding classes and instances
             embedding_string = embedding_model.to_s
-            _embedding_klass = self.class.embedding_klass(embedding_model)
+            _embedding_klass = self.class.symbol_to_class(embedding_model)
             embedding_instance = eval(embedding_string)
             if embedding_instance
               id_to_destroy = changed_embedding_instance || embedding_instance.id
@@ -108,7 +108,7 @@ module Mongoid
         index_params << ", :index => true" if embedding_options[:index]
         index_params << ", :background => true" if embedding_options[:index] && embedding_options[:background_index]
   
-        embedding_models.each do |embedding_model|
+        embedding_models[:all].each do |embedding_model|
           self.class_eval <<-EOT
             belongs_to :#{embedding_model} #{index_params}
           EOT

data/lib/mongoid-mirrored/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Mirrored
-    VERSION = "0.0.2"
+    VERSION = "0.0.3"
   end
 end

data/perf/benchmark.rb

@@ -0,0 +1,183 @@
+require "benchmark"
+require "mongoid"
+require "mongoid-mirrored"
+
+def rand_post(posts)
+  posts[rand(posts.size)]
+end
+
+Mongoid.configure do |config|
+  config.master = Mongo::Connection.new.db("mongoid_perf_test")
+end
+Mongoid.logger = Logger.new($stdout)
+
+Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+
+class Post
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  
+  field :title
+  has_many :comments
+  
+end
+
+class Comment
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  field :contents
+  
+  belongs_to :post, :index => true
+end
+
+puts "----------------------------------------------------"
+puts "Benchmark for referenced documents"
+puts "----------------------------------------------------"
+
+Benchmark.bm do |bm|
+  500.times do 
+    Post.create
+  end
+  
+  posts = Post.all.to_a
+  
+  bm.report "creating 10000 comments in 200 posts from root collection" do
+    10000.times do
+      Comment.create(:post => rand_post(posts))
+    end
+  end
+  
+  bm.report "updating 10000 comments from root collection" do
+    Comment.all.each_with_index do |c,i|
+      c.update_attribute(:contents, i)
+    end
+  end
+  
+  bm.report "traversing posts with comments 10000 times" do
+    10000.times do 
+      p = rand_post(posts)
+      p.comments.each do |c|
+        (con ||= []) << c.contents
+      end
+    end
+  end
+  
+  bm.report "finding posts from the 1000 newest comments" do
+    titles = []
+    Comment.where(:contents.gt => 9000).each{|c| titles << c.post.title}
+  end
+  
+  bm.report "deleting 10000 comments from root collection" do
+    Comment.all.map(&:destroy)
+  end
+  
+  bm.report "creating 10000 comments in 200 posts from embedding collection" do
+    10000.times do
+      p = rand_post(posts)
+      p.comments.create
+    end
+  end
+  
+  bm.report "updating 10000 comments from embedding collection" do
+    posts.each do |p|
+      p.comments.each_with_index do |c,i|
+        c.update_attribute(:contents, i)
+      end
+    end
+  end
+  
+  bm.report "deleting 10000 comments from embedding collection" do
+    posts.each do |p|
+      p.comments.map(&:destroy)
+    end
+  end
+end
+
+Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+
+Object.send :remove_const, "Post"
+class Post
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  
+  field :title
+  embeds_many :comments, :class_name => "Post::Comment"
+end
+
+Object.send :remove_const, "Comment"
+class Comment
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::Mirrored
+  
+  field :contents
+  
+  belongs_to :post
+  
+  mirrored_in :post, :index => true do
+    field :contents
+    field :counter, :type => Integer
+  end
+end
+
+puts "----------------------------------------------------"
+puts "Benchmark for mirrored documents"
+puts "----------------------------------------------------"
+Benchmark.bm do |bm|
+  500.times do 
+    Post.create
+  end
+  
+  posts = Post.all.to_a
+  
+  bm.report "creating 10000 comments in 200 posts from root collection" do
+    10000.times do
+      Comment.create(:post => rand_post(posts))
+    end
+  end
+  
+  bm.report "updating 10000 comments from root collection" do
+    Comment.all.each_with_index do |c,i|
+      c.update_attribute(:contents, i)
+    end
+  end
+  
+  bm.report "traversing posts with comments 10000 times" do
+    10000.times do 
+      p = rand_post(posts)
+      p.comments.each do |c|
+        (con ||= []) << c.contents
+      end
+    end
+  end
+  
+  bm.report "finding posts from the 1000 newest comments" do
+    titles = []
+    Post.where(:"comments.contents".gt => 9000).each{|p| titles << p.title}
+  end
+  
+  bm.report "deleting 10000 comments from root collection" do
+    Comment.all.map(&:destroy)
+  end
+  
+  bm.report "creating 10000 comments in 200 posts from embedding collection" do
+    10000.times do
+      p = rand_post(posts)
+      p.comments.create
+    end
+  end
+  
+  bm.report "updating 10000 comments from embedding collection" do
+    posts.each do |p|
+      p.comments.each_with_index do |c,i|
+        c.update_attribute(:contents, i)
+      end
+    end
+  end
+  
+  bm.report "deleting 10000 comments from embedding collection" do
+    posts.each do |p|
+      p.comments.map(&:destroy)
+    end
+  end
+end

data/spec/functional/mongoid/comment_spec.rb

@@ -61,6 +61,9 @@ describe "Comment" do
         c = article.comments.create(:contents => "embedding", :author => "embedding_author")
         Comment.first.update_attributes(:article_id =>  Article.create.id, :user_id => User.create.id)
         article.reload
+        # puts article.inspect
+        # puts article.comments.inspect
+        # puts Comment.all.to_a.inspect
         article.comments.should be_empty
         user.reload
         user.comments.should be_empty
@@ -99,7 +102,7 @@ describe "Comment" do
     it "should destroy document in root collection" do
       c  = Comment.create(:article => article, :user => user, :contents => "root", :author => "root_author" )
       c.destroy
-      Comment.where(:content => "root").should be_empty
+      Comment.where(:contents => "root").should be_empty
     end
     
     it "should destroy similar document in each embedding collection" do
@@ -116,14 +119,14 @@ describe "Comment" do
     it "should destroy document in root collection" do
       c = article.comments.create(:contents => "embedding", :author => "embedding_author")
       c.destroy
-      Comment.where(:content => "embedding").should be_empty
+      Comment.where(:contents => "embedding").should be_empty
     end
     
     it "should destroy similar document from embedding collection" do
       c = article.comments.create(:contents => "embedding", :author => "embedding_author")
       c.destroy
       article.reload
-      article.comments.where(:content => "embedding").should be_empty
+      article.comments.where(:contents => "embedding").should be_empty
     end
     
     it "should destroy document from sibling collections" do

data/spec/unit/mirror_attributes.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe "Mongoid::Mirrored" do
+  
+  context "Mirror Attributes" do
+    let(:mirror) { Article::Comment.new }
+    
+    it "should define class accessor attribute for root association" do
+      mirror.class.mirror_attributes[:root][:association].should == :comments
+    end
+    
+    it "should define class accessor attribute for root class" do
+      mirror.class.mirror_attributes[:root][:klass].should == Comment
+    end
+    
+    it "should define class accessor attribute for embedding sym" do
+      mirror.class.mirror_attributes[:embedding][:sym].should == :article
+    end
+    
+    it "should define class accessor for mirror embedding class" do
+      mirror.class.mirror_attributes[:embedding][:klass].should == Article
+    end
+    
+    it "should define class accessor for mirror embedding id" do
+      mirror.class.mirror_attributes[:embedding][:id].should == :article_id
+    end
+    
+    it "should define class accessor for mirror embedding instance" do
+      mirror.class.mirror_attributes[:embedding][:klass].should == "article"
+    end
+    
+  end
+
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Alexandre Angelim
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-24 00:00:00 -03:00
+date: 2011-05-25 00:00:00 -03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -81,8 +81,8 @@ files:
 - lib/mongoid-mirrored/mirrored_in.rb
 - lib/mongoid-mirrored/root/root_methods.rb
 - lib/mongoid-mirrored/version.rb
-- lib/performance/performance.rb
 - mongoid-mirrored.gemspec
+- perf/benchmark.rb
 - spec/functional/mongoid/comment_spec.rb
 - spec/models/article.rb
 - spec/models/comment.rb
@@ -93,6 +93,7 @@ files:
 - spec/unit/associations_spec.rb
 - spec/unit/callback_specs.rb
 - spec/unit/index_spec.rb
+- spec/unit/mirror_attributes.rb
 - spec/unit/options_spec.rb
 - spec/unit/shared_fields_spec.rb
 has_rdoc: true
@@ -138,5 +139,6 @@ test_files:
 - spec/unit/associations_spec.rb
 - spec/unit/callback_specs.rb
 - spec/unit/index_spec.rb
+- spec/unit/mirror_attributes.rb
 - spec/unit/options_spec.rb
 - spec/unit/shared_fields_spec.rb

data/lib/performance/performance.rb

@@ -1,161 +0,0 @@
-require "benchmark"
-require "mongoid"
-
-def rand_post(posts)
-  posts[rand(posts.size)]
-end
-
-Mongoid.configure do |config|
-  config.master = Mongo::Connection.new.db("mongoid_perf_test")
-end
-Mongoid.logger = Logger.new($stdout)
-
-Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
-
-class Post
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  
-  field :title
-  # embeds_many :comments, :class_name => "Post::Comment"
-  has_many :comments
-  
-end
-
-class Comment
-  include Mongoid::Document
-  include Mongoid::Timestamps
-  field :contents
-  # include Mongoid::Mirrored
-  
-  # mirrored_in :post, :belongs => true do
-  #   field :contents
-  #   field :counter, :type => Integer
-  # end
-  belongs_to :post, :index => true
-end
-
-Benchmark.bm do |bm|
-  10000.times do 
-    Post.create
-  end
-  
-  posts = Post.all.to_a
-  
-	bm.report "criando comments da raiz" do
-		10000.times do
-			Comment.create(:post => rand_post(posts))
-		end
-	end
-	
-	bm.report "atualizando comments da raiz" do
-		Comment.all.each_with_index do |c,i|
-			c.update_attribute(:contents, i)
-		end
-	end
-	
-	
-	bm.report "leitura de var no relacionamento" do
-	  posts.each do |p|
-  	  p.comments.each do |c|
-  	    (con ||= []) << c.contents
-      end
-    end
-  end
-	
-	bm.report "apagando comments da raiz" do
-		Comment.all.map(&:destroy)
-	end
-	
-	bm.report "criando comments do embedded" do
-		10000.times do
-		  p = rand_post(posts)
-			p.comments.create
-		end
-	end
-	
-	bm.report "atualizando comments da embedded" do
-    posts.each do |p|
-  		p.comments.each_with_index do |c,i|
-  			c.update_attribute(:contents, i)
-  		end
-  	end
-	end
-	
-	bm.report "apagando comments da embedded" do
-	  posts.each do |p|
-  		p.comments.map(&:destroy)
-  	end
-	end	
-end
-
-Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
-
-class Post
-  embeds_many :comments, :class_name => "Post::Comment"
-  # Post.collection.create_index "comments._id"
-end
-
-class Comment
-  include Mongoid::Mirrored
-  
-  mirrored_in :post, :belongs => true do
-    field :contents
-    field :counter, :type => Integer
-  end
-end
-
-
-Benchmark.bm do |bm|
-  10000.times do 
-    Post.create
-  end
-  
-  posts = Post.all.to_a
-  
-	bm.report "criando comments da raiz" do
-		10000.times do
-			Comment.create(:post => rand_post(posts))
-		end
-	end
-	
-	bm.report "atualizando comments da raiz" do
-		Comment.all.each_with_index do |c,i|
-			c.update_attribute(:contents, i)
-		end
-	end
-	
-	
-	bm.report "leitura de var no relacionamento" do
-	  posts.each do |p|
-  	  p.comments.each do |c|
-  	    (con ||= []) << c.contents
-      end
-    end
-  end
-	
-	bm.report "apagando comments da raiz" do
-		Comment.all.map(&:destroy)
-	end
-	
-	bm.report "criando comments do embedded" do
-		10000.times do
-		  p = rand_post(posts)
-			p.comments.create
-		end
-	end
-	
-	bm.report "atualizando comments da embedded" do
-    posts.each do |p|
-  		p.comments.each_with_index do |c,i|
-  			c.update_attribute(:contents, i)
-  		end
-  	end
-	end
-	
-	bm.report "apagando comments da embedded" do
-	  posts.each do |p|
-  		p.comments.map(&:destroy)
-  	end
-	end	
-end