mongoid-mirrored 0.0.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.2

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mongoid-rspec.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Alexandre Angelim
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,131 @@
+Mongoid::Mirrored
+====================
+
+Helper module for mirroring root documents in embedded collections. Works with [Mongoid](https://github.com/mongoid/mongoid). 
+
+When adopting the mindset of document base storages we can understand the advantages of representing a document with all its related content as opposed to the relational database approach of referencing information scattered across a number of other collections. That doesn't only help in understanding better the data model we have in our hands, but also usually provides better read performances in our applications. Although the document based mindset can come naturally for most of us, some still struggle when trying to adopt this new paradigm (myself included) and end up modeling our data closely of what we would have done in a relational database. Sometimes that happens because can't be sure of that data access patterns in advance or we just fear denormalization. 
+
+Mongoid provides an intuitive interface to reference documents among different collections, but that comes at a cost. As MongoDB doesn't support joins and relying heavily on relational data reads, that could be a problem for some applications. Unfortunately, Mongoid doens't support embedding collections while maintaining an independent root collection and that is exactly the intention with mirrored documents.  
+
+I couldn't find anything that helped me with that, but this [discussion](http://groups.google.com/group/mongoid/browse_thread/thread/b5e2bccf77457043) at the mongoid group where Durran stated that it was unlikely that mongoid would go in that direction. 
+
+This gem has been inspired by that conversation and also [Mongoid::Denormalize](https://github.com/logandk/mongoid_denormalize) which you should definitelly check out if you have similar needs.
+
+I'm not an experienced developer(in fact I work as a Product Manager and develop only to bootstrap proofs of concept) and I'm new to document database storages. Please feel free to contribute to this gem or point out the correct approach for this.
+
+Installation
+------------
+
+Add the gem to your Bundler `Gemfile`:
+
+    gem 'mongoid-mirrored'
+
+Or install with RubyGems:
+
+    $ gem install mongoid-mirrored
+
+
+Usage
+-----
+
+In your root(master) model:
+
+	# Include the helper module
+	include Mongoid::Mirrored
+
+	# Define wich fields and methods will be shared among root and embedded classes
+	mirrored_in :articles, :users, :sync_direction => :both, :sync_events => :all do
+		field :contents, :type => String
+		field :vote_ratio, :type => Float
+	
+		def calculate_vote_ratio
+			# do something with votes
+		end
+	end
+    
+
+Example
+-------
+
+	# The conventioned name for the mirrored class is "#{embedding_class}::{root_class}"
+
+	class Post
+	  embeds_many :comments, :class_name => "Post::Comment"
+	end
+
+	class User
+	  embeds_many :comments, :class_name => "User::Comment"
+	end
+
+	# The Root Class should establish with which classes it is supposed to sync documents.
+	# Everything declared within the block will be shared between the root and mirrored 
+	# documents (eg. fields, instance methods, class methods)
+
+	class Comment
+		mirrored_in :post, :user, :sync_direction => :both do
+			field :contents
+			field :vote_ratio, :type => Integer
+			def	foo
+			 "bar"
+			end
+		end
+	end
+
+Options
+-------
+	
+	sync_events
+	-----------
+		:all(default) => sync master and mirrored documents on :after_create, :after_update and :after_destroy callbacks
+		:create => syncs only on :after_create
+		:update => syncs only on :after_update
+		:destroy => syncs only on :after_destroy
+	this options accepts an Array of events (eg: [:create, :destroy])	
+	
+	sync_direction
+	--------------
+		:both(default) => syncs documents on both directions. From master(root) to mirrors and from mirror to master
+		:from_root => syncs only from master to mirrors
+		:from_mirror => syncs only from mirror to master
+		
+	replicate_to_siblings
+	---------------------
+	true(default) => perform operations on the mirror's siblings 
+	(eg: article.comments.create(:user_id => user.id) will replicate the document on the User::Comment collection)
+
+	inverse_of
+	----------
+	:one => 
+	:many(default)
+	
+	index
+	-----
+	false(default) => determines whether the root collection will create an index on the embedding collection's foreign_key
+	
+	index_background
+	----------------
+	false(default) => determines whether the aforementioned index will run on background
+	
+	
+Rake tasks
+----------
+
+should include tasks to re-sync
+
+
+Known issues
+------------
+
+- The helper does not support multiple calls of the mirrored_in method
+- Changing parents from the embedded association does not update target documents. Use the master collection to change associations.
+	- eg post.comments.first.update_attribute(:post_id => Post.create) does not include the comment in the new Post comments list
+
+Performance
+------------
+
+perf/performance.rb
+
+Credits
+-------
+
+Copyright (c) 2011 Alexandre Angelim, released under the MIT license.

data/Rakefile

@@ -0,0 +1,22 @@
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+require "rspec"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new("spec:functional") do |spec|
+  spec.rspec_opts = %w(--format progress)
+  spec.pattern = "spec/functional/**/*_spec.rb"
+end
+
+task :default => :spec
+task :test => :spec
+
+require 'rake/rdoctask'
+require "mongoid-mirrored/version"
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "mongoid-mirrored #{Mongoid::Mirrored::VERSION}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/mongoid-mirrored.rb

@@ -0,0 +1,2 @@
+require 'mongoid'
+require 'mongoid-mirrored/mirrored_in'

data/lib/mongoid-mirrored/helper_methods.rb

@@ -0,0 +1,39 @@
+module Mongoid
+  module Mirrored
+    module HelperMethods
+      def extract_options(*args)
+        options = args.extract_options!
+        self.embedding_models = args
+        self.embedding_options = options
+        
+        # set defaults
+        self.embedding_options[:sync_events] ||= :all
+        self.embedding_options[:sync_events] = [self.embedding_options[:sync_events]] unless embedding_options[:sync_events].is_a? Array
+        self.embedding_options[:sync_direction] ||= :both
+        self.embedding_options[:replicate_to_siblings] = true if self.embedding_options[:replicate_to_siblings].nil?
+        self.embedding_options[:inverse_of] ||= :many
+        self.embedding_options[:index] = false if self.embedding_options[:index].nil?
+        self.embedding_options[:background_index] = false if self.embedding_options[:background_index].nil?
+      end
+      
+      # name of the association used by the embedding class
+      # eg: comments
+      def root_association
+        inverse_of = @root_klass.name.underscore
+        inverse_of = inverse_of.pluralize if embedding_options[:inverse_of] == :many
+        inverse_of
+      end
+      
+      def embedding_klass(embedding_sym)
+        begin
+          _embedding_klass = embedding_sym.to_s.classify.constantize 
+        rescue
+          Object.const_set embedding_sym.to_s.classify, Class.new 
+        ensure
+          _embedding_klass = embedding_sym.to_s.classify.constantize 
+        end
+      end
+    end
+  end
+end
+  

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

@@ -0,0 +1,146 @@
+module Mongoid
+  module Mirrored
+    module MirrorMethods
+      
+      def embeds_mirror_in(_embedding_model, mirror_klass)
+        # mongoid macro embedded_in
+        # eg: embedded_in :post, :inverse_of => :comments
+        
+        mirror_klass.class_eval <<-EOT
+          embedded_in :#{_embedding_model}, :inverse_of => :#{root_association}
+        EOT
+      end
+      
+      def define_after_create_callback(_embedding_model, mirror_klass)
+        unless mirror_klass.instance_methods.include?(:_create_root)
+          mirror_klass.class_eval <<-EOF
+            after_create  :_create_root
+          EOF
+        end
+
+        mirror_klass.class_eval <<-EOF
+          def _create_root
+            #{@root_klass}.collection.insert(attributes.merge(:#{_embedding_model}_id => #{_embedding_model}.id))
+          end
+        EOF
+      end
+      def define_after_update_callback(_embedding_model, mirror_klass)
+        unless mirror_klass.instance_methods.include?(:_update_root)
+          mirror_klass.class_eval <<-EOF
+            after_update  :_update_root
+          EOF
+        end
+
+        mirror_klass.class_eval <<-EOF
+           def _update_root
+             #{@root_klass}.collection.update({ :_id => id }, '$set' => attributes.except('_id'))
+           end
+         EOF
+      end
+
+      def define_after_destroy_callback(_embedding_model, mirror_klass)
+        unless mirror_klass.instance_methods.include?(:_destroy_root)
+          mirror_klass.class_eval <<-EOF
+            after_destroy  :_destroy_root
+          EOF
+        end
+
+        mirror_klass.class_eval <<-EOF
+           def _destroy_root
+             #{@root_klass}.collection.update({ :_id => id }, '$set' => attributes.except('_id'))
+           end
+         EOF
+      end
+
+      def define_after_create_siblings(_embedding_model, mirror_klass)
+        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|
+              _sibling = sibling.to_s
+              next if sibling == :#{_embedding_model}
+              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)})
+              end
+            end
+          end
+        EOF
+      end
+
+      def define_after_update_siblings(_embedding_model, mirror_klass)
+        unless mirror_klass.instance_methods.include?(:_update_siblings)
+          mirror_klass.class_eval <<-EOF
+            after_update  :_update_siblings
+          EOF
+        end
+        mirror_klass.class_eval <<-EOF
+          def _update_siblings
+            #{embedding_models}.each do |sibling|
+              _sibling = sibling.to_s
+              next if sibling == :#{_embedding_model}
+              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
+                end
+                sibling_klass.collection.update({"#{root_association}._id" => id}, '$set' => nested_attr )
+              end
+            end
+          end
+        EOF
+      end
+
+      def define_after_destroy_siblings(_embedding_model, mirror_klass)
+        unless mirror_klass.instance_methods.include?(:_destroy_siblings)
+          mirror_klass.class_eval <<-EOF
+            after_destroy  :_destroy_siblings
+          EOF
+        end
+        mirror_klass.class_eval <<-EOF
+          def _destroy_siblings
+            #{embedding_models}.each do |sibling|
+              _sibling = sibling.to_s
+              next if sibling == :#{_embedding_model}
+              sibling_klass = sibling.to_s.classify.constantize
+              if self[_sibling+"_id"]
+                sibling_klass.collection.update({ :_id => self[_sibling+"_id"] }, '$pull' => {:#{root_association} => { :_id => id}})
+              end
+            end
+          end
+        EOF
+      end
+
+      # Define callbacks for mirror class that don't trigger callbacks on the root class
+      def define_mirror_callbacks_for(_embedding_model, mirror_klass)
+        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)
+            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)
+            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)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid-mirrored/mirrored_in.rb

@@ -0,0 +1,41 @@
+require "mongoid-mirrored/mirror/mirror_methods.rb"
+require "mongoid-mirrored/root/root_methods.rb"
+require "mongoid-mirrored/helper_methods.rb"
+
+module Mongoid
+  module Mirrored
+    def self.included(base)
+      base.send(:extend, ClassMethods)
+      base.send :cattr_accessor, :embedding_models
+      base.send :cattr_accessor, :embedding_options
+    end
+    
+    module ClassMethods
+      include Mongoid::Mirrored::MirrorMethods
+      include Mongoid::Mirrored::RootMethods
+      include Mongoid::Mirrored::HelperMethods
+      
+      def mirrored_in(*args, &block)
+        extract_options(*args)
+        write_fields_with_options { yield }
+        @root_klass = self
+        # creates a Mirrored class for each embedding model
+        embedding_models.each do |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)
+          
+          # Creates the mirrored class Embedding::Root
+          _embedding_klass.const_set self.name, mirror_klass
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+module Mongoid
+  module Mirrored
+    module RootMethods
+      # Define callbacks for root class that don't trigger callbacks on the mirror classes
+      def define_root_callbacks
+        if [:both, :from_root].include?(embedding_options[:sync_direction])
+          if embedding_options[:sync_events].include?(:create) || embedding_options[:sync_events] == [:all]
+            define_create_mirrors
+          end
+    
+          if embedding_options[:sync_events].include?(:update) || embedding_options[:sync_events] == [:all]
+            define_update_mirrors
+          end
+    
+          if embedding_options[:sync_events].include?(:destroy) || embedding_options[:sync_events] == [:all]
+            define_destroy_mirrors
+          end
+        end
+      end
+
+      def define_create_mirrors
+        unless self.instance_methods.include?(:_create_mirrors)
+          self.class_eval <<-EOF
+            after_create  :_create_mirrors
+          EOF
+        end
+        define_method :_create_mirrors do
+    
+          # 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|
+            # 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_instance = eval(embedding_string)
+      
+            # Only tries to create mirrored document if the embedding instance is given
+            if embedding_instance
+              _embedding_klass.collection.update({ :_id => embedding_instance.id }, '$push' => {self.class.root_association => attributes.except("#{embedding_string}_id")})
+            end
+          end
+        end
+      end
+
+      def define_update_mirrors
+        unless self.instance_methods.include?(:_update_mirrors)
+          self.class_eval <<-EOF
+            before_update  :_update_mirrors
+          EOF
+        end
+        # updates the mirrored document when one or more attributes of the parent document is changed
+        # 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|
+      
+            # 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)
+      
+            if embedding_instance
+              if eval("#{embedding_string}_id_changed?")
+                _create_mirrors
+                _destroy_mirrors(eval("#{embedding_string}_id_was"))
+              else
+                # using positional modifier $ to find embedded document to be updated
+                # traverses the attributes hash to inject positional modifier
+                # eg: contents => ;comments.$.contents =>
+                nested_attr = {}
+                attributes.except("#{embedding_string}_id").each_pair do |k,v|
+                  nested_attr["#{self.class.root_association}.$.#{k}"] = v
+                end
+                _embedding_klass.collection.update({"#{self.class.root_association}._id" => id}, '$set' => nested_attr )
+              end
+            end
+          end
+        end
+      end
+
+      def define_destroy_mirrors
+        unless self.instance_methods.include?(:_destroy_mirrors)
+          self.class_eval <<-EOF
+            after_destroy  :_destroy_mirrors
+          EOF
+        end
+        # 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|
+      
+            # 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_instance = eval(embedding_string)
+            if embedding_instance
+              id_to_destroy = changed_embedding_instance || embedding_instance.id
+              _embedding_klass.collection.update({ :_id => id_to_destroy }, '$pull' => {self.class.root_association => { :_id => id}})
+            end
+          end
+        end
+      end
+
+      # writes the block passed to the mirrored_in method in the Root Calss
+      # defines instance methods used in callbacks triggered by the root documents
+      def write_fields_with_options(&block)
+        index_params = ""
+        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|
+          self.class_eval <<-EOT
+            belongs_to :#{embedding_model} #{index_params}
+          EOT
+        end
+        # writes shared fields and methods to root document
+        yield
+  
+        define_root_callbacks
+  
+      end
+    end
+  end
+end

data/lib/mongoid-mirrored/version.rb

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

data/lib/performance/performance.rb

@@ -0,0 +1,161 @@
+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

data/mongoid-mirrored.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mongoid-mirrored/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mongoid-mirrored"
+  s.version     = Mongoid::Mirrored::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors = ["Alexandre Angelim"]
+  s.email = %q{angelim@angelim.com.br}  
+  s.homepage = %q{http://github.com/angelim/mongoid-mirrored}    
+  s.summary = %q{Mirrored Embeds for Mongoid}  
+  s.description = %q{Create mirrors of root documents embeded in other models and keep them in sync}
+    
+  s.rubyforge_project = "mongoid-mirrored"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.add_runtime_dependency(%q<mongoid>, ["~> 2.0"])
+  s.add_development_dependency("rspec", ["~> 2.6"])
+  s.add_development_dependency("bson_ext", ["~> 1.3"])
+end

data/spec/functional/mongoid/comment_spec.rb

@@ -0,0 +1,146 @@
+# test methods
+# test from_mirror
+require 'spec_helper'
+
+describe "Comment" do
+  let(:article) { Article.create }
+  let(:user) { User.create }
+  context "creating from the root collection" do
+    it "should create document in root collection" do
+      c = Comment.create(:article => article, :contents => "root", :author => "root_author" )
+      Comment.where(:contents => "root").first.should == c
+    end
+    
+    it "should create similar document in each embedding collection" do
+      c  = Comment.create(:article => article, :user => user, :contents => "root", :author => "root_author" )
+      article.reload
+      article.comments.find(c.id.to_s).should_not be_nil
+      user.reload
+      user.comments.find(c.id.to_s).should_not be_nil
+    end
+    
+  end
+  
+  context "creating from the embedding collection" do
+    it "should create document in root collection" do
+      c = article.comments.create(:contents => "embedding", :author => "embedding_author")
+      Comment.find(c.id).should_not be_nil
+    end
+    
+    it "should create similar document in embedding collection" do
+      c = article.comments.create(:contents => "embedding", :author => "embedding_author")
+      article.reload
+      c.article.should == article
+    end
+    
+    it "should replicate document to sibling collections" do
+      c = article.comments.create(:user_id => user.id, :contents => "embedding", :author => "embedding_author")
+      user.reload
+      user.comments.find(c.id).should_not be_nil
+    end
+  end
+
+  context "updating from the root collection" do
+    it "should update document in root collection" do
+      c  = Comment.create(:article => article, :contents => "root", :author => "root_author" )
+      c.update_attributes(:contents => "new_root", :author => "new_author_root")
+      Comment.where(:contents => "new_root", :author => "new_author_root").first.should == c
+
+    end
+    
+    it "should update document in embedding collection with new attributes" do
+      c  = Comment.create(:article => article, :user => user, :contents => "root", :author => "root_author" )
+      c.update_attributes(:contents => "new_root", :author => "new_author_root")
+      article.reload
+      article.comments.where(:contents => "new_root", :author => "new_author_root").first.id.should == c.id
+      user.reload
+      user.comments.where(:contents => "new_root", :author => "new_author_root").first.id.should == c.id
+    end
+    context "switching embedding document" do
+      it "should delete comment from embedding original collection" 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
+        article.comments.should be_empty
+        user.reload
+        user.comments.should be_empty
+      end
+      it "should create comment in new embedding collection" do
+        c = article.comments.create(:contents => "embedding", :author => "embedding_author")
+        Comment.first.update_attribute(:article_id, Article.create.id)
+        Article.last.comments.where(:contents => "embedding").should_not be_empty
+      end
+    end
+  end
+  
+  context "updating from the embedding collection" do
+    it "should update document in root collection with new attributes" do
+      c = article.comments.create(:contents => "embedding", :author => "embedding_author")
+      c.update_attributes(:contents => "new_embedding", :author => "new_author_embedding")
+      Comment.where(:contents => "new_embedding", :author => "new_author_embedding").first.id.should == c.id
+    end
+    
+    it "should update similar document in embedding collection" do
+      c = article.comments.create(:contents => "embedding", :author => "embedding_author")
+      c.update_attributes(:contents => "new_embedding", :author => "new_author_embedding")
+      article.reload
+      article.comments.where(:contents => "new_embedding", :author => "new_author_embedding").first.id.should == c.id
+    end
+    
+    it "should replicate changes to sibling collections" do
+      c = article.comments.create(:user_id => user.id, :contents => "embedding", :author => "embedding_author")
+      c.update_attributes(:contents => "new_embedding", :author => "new_author_embedding")
+      user.reload
+      user.comments.find(c.id).contents.should == "new_embedding"
+    end
+  end
+  
+  context "destroying from the root collection" 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
+    end
+    
+    it "should destroy similar document in each embedding collection" do
+      c  = Comment.create(:article => article, :user => user, :contents => "root", :author => "root_author" )
+      c.destroy
+      article.reload
+      article.comments.where(:contents => "root").should be_empty
+      user.reload
+      user.comments.where(:contents => "root").should be_empty
+    end
+  end
+  
+  context "destroy from the embedding collection" 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
+    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
+    end
+    
+    it "should destroy document from sibling collections" do
+      c = article.comments.create(:user_id => user.id, :contents => "embedding", :author => "embedding_author")
+      c.destroy
+      user.reload
+      user.comments.where(:_id => c.id).should be_empty
+    end
+  end
+  
+  context "shared methods between root and mirrored classes" do
+    it "should be able to call shared methods from the root collection" do
+      Comment.new.foo.should == "bar"
+    end
+    it "should be able to call shared methods from the mirrored collection" do
+      article.comments.new.foo.should == "bar"
+    end
+  end
+  
+end

data/spec/models/article.rb

@@ -0,0 +1,11 @@
+class Article
+  include Mongoid::Document
+  
+  field :title
+  index :title
+  field :content
+  field :published, :type => Boolean, :default => false
+
+  embeds_many :comments, :class_name => "Article::Comment"
+end
+  

data/spec/models/comment.rb

@@ -0,0 +1,15 @@
+class Comment
+  include Mongoid::Document
+  include Mongoid::Mirrored
+  
+  field :dummy
+  mirrored_in :article, :user do
+    field :author
+    field :contents
+    field :like_count, :type => Integer, :default => 0
+    
+    def foo
+      "bar"
+    end
+  end
+end

data/spec/models/comment_with_less_option.rb

@@ -0,0 +1,14 @@
+class CommentWithLessOption
+  include Mongoid::Document
+  include Mongoid::Mirrored
+  
+  field :dummy
+  mirrored_in :article,
+              :sync_direction => :from_root,
+              :replicate_to_siblings => true do
+                
+    field :author
+    field :contents
+    field :like_count, :type => Integer, :default => 0
+  end
+end

data/spec/models/comment_with_option.rb

@@ -0,0 +1,18 @@
+class CommentWithOption
+  include Mongoid::Document
+  include Mongoid::Mirrored
+  
+  field :dummy
+  mirrored_in :article,
+              :inverse_of => :one, 
+              :sync_direction => :from_mirror,
+              :sync_events => [:create, :update], 
+              :index => true,
+              :background_index => true,
+              :replicate_to_siblings => false do
+                
+    field :author
+    field :contents
+    field :like_count, :type => Integer, :default => 0
+  end
+end

data/spec/models/user.rb

@@ -0,0 +1,5 @@
+class User
+  include Mongoid::Document
+  field :name
+  embeds_many :comments, :class_name => "User::Comment"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "lib"))
+MODELS = File.join(File.dirname(__FILE__), "models")
+$LOAD_PATH.unshift(MODELS)
+
+require "rubygems"
+require "bundler"
+Bundler.setup
+
+require 'rspec'
+require 'mongoid'
+require 'mongoid-mirrored'
+
+Mongoid.configure do |config|
+  name = "mongoid-mirrored-test"
+  host = "localhost"
+  config.master = Mongo::Connection.new.db(name)
+  config.autocreate_indexes = true
+end
+
+Dir[ File.join(MODELS, "*.rb") ].sort.each { |file| require File.basename(file) }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+  config.after :each do
+    Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+  end
+end

data/spec/unit/associations_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe "Mongoid::Mirrored" do
+
+  context "Embedding Class" do
+    it "should embeds the mirrored document under the correct class name" do
+      Article.reflect_on_association(:comments).class_name.should == "Article::Comment"
+    end
+  end
+  
+  context "Root Class" do
+    let(:comment) { Comment.new }
+
+    it "should reflect on association with Article" do
+      comment.fields.should have_key "article_id"
+      comment.reflect_on_association(:article).macro.should == :referenced_in
+    end
+  end
+  
+  context "Article::Comment Mirror Class" do
+    let(:mirror) { Article::Comment.new }
+
+    it "should reflect on association with Article" do
+      mirror.reflect_on_association(:article).macro.should == :embedded_in
+      mirror.reflect_on_association(:article).inverse_of.should == :comments
+    end
+
+  end
+  
+  context "Article::CommentWithOption Mirror Class" do
+    let(:mirror) { Article::CommentWithOption.new }
+
+    it "should reflect on association with Article" do
+      mirror.reflect_on_association(:article).macro.should == :embedded_in
+      mirror.reflect_on_association(:article).inverse_of.should == :comment_with_option
+    end
+
+  end
+  
+  context "Article::CommentWithLessOption Mirror Class" do
+    let(:mirror) { Article::CommentWithLessOption.new }
+    
+    it "should reflect on association with Article" do
+      mirror.reflect_on_association(:article).macro.should == :embedded_in
+      mirror.reflect_on_association(:article).inverse_of.should == :comment_with_less_options
+    end
+
+  end
+end

data/spec/unit/callback_specs.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe "Mongoid::Mirrored" do
+  
+  context "Root Class" do
+    let(:comment) { Comment.new }
+    
+    it "should define callbacks if sync strategy is ..." do
+      Comment._create_callbacks.map(&:filter).should include :create_mirror
+      Comment._update_callbacks.map(&:filter).should include :update_mirror
+      Comment._destroy_callbacks.map(&:filter).should include :destroy_mirror
+    end
+
+  end
+  
+  context "Article::Comment Mirror Class" do
+    let(:mirror) { Article::Comment.new }
+    
+    it "should define callbacks for sync strategy" do
+      mirror._create_callbacks.map(&:filter).should include :_create_root
+      mirror._update_callbacks.map(&:filter).should include :_update_root
+      mirror._destroy_callbacks.map(&:filter).should include :_destroy_root
+    end
+  end
+  
+  context "Article::CommentWithOption Mirror Class" do
+    let(:mirror) { Article::CommentWithOption.new }
+    
+    it "should define callbacks for sync strategy" do
+      mirror._create_callbacks.map(&:filter).should include :_create_root
+      mirror._update_callbacks.map(&:filter).should include :_update_root
+      mirror._destroy_callbacks.map(&:filter).should_not include :_destroy_root
+    end
+  end
+  
+  context "Article::CommentWithLessOption Mirror Class" do
+    let(:mirror) { Article::CommentWithLessOption.new }
+
+    it "should define callbacks for sync strategy" do
+      mirror._create_callbacks.map(&:filter).should_not include :_create_root
+      mirror._update_callbacks.map(&:filter).should_not include :_update_root
+      mirror._destroy_callbacks.map(&:filter).should_not include :_destroy_root
+    end
+  end
+end

data/spec/unit/index_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe "Mongoid::Mirrored" do
+
+  
+  context "Article::CommentWithOption Mirror Class" do
+    let(:mirror) { Article::CommentWithOption.new }
+    
+    it "should create index on association with Article" do
+      CommentWithOption.collection.index_information().should include("article_id_1")
+    end
+  end
+
+end

data/spec/unit/options_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe "Mongoid::Mirrored" do
+  it "#sync_events" do
+    Comment.embedding_options[:sync_events].should == [:all]
+    CommentWithOption.embedding_options[:sync_events].should == [:create, :update]
+    CommentWithLessOption.embedding_options[:sync_events].should == [:all]
+  end
+  
+  it "#sync_direction" do
+    Comment.embedding_options[:sync_direction].should == :both
+    CommentWithOption.embedding_options[:sync_direction].should == :from_mirror
+    CommentWithLessOption.embedding_options[:sync_direction].should == :from_root
+  end
+  
+  it "#replicate_to_siblings" do
+    Comment.embedding_options[:replicate_to_siblings].should == true
+
+    CommentWithOption.embedding_options[:replicate_to_siblings].should == false
+
+    CommentWithLessOption.embedding_options[:replicate_to_siblings].should == true
+  end
+  
+  it "#inverse_of" do
+    Comment.embedding_options[:inverse_of].should == :many
+    CommentWithOption.embedding_options[:inverse_of].should == :one
+    CommentWithLessOption.embedding_options[:inverse_of].should == :many
+  end
+  
+  it "#index" do
+    Comment.embedding_options[:index].should == false
+    CommentWithOption.embedding_options[:index].should == true
+    CommentWithLessOption.embedding_options[:index].should == false
+  end
+  
+  it "#background_index" do
+    Comment.embedding_options[:background_index].should == false
+    CommentWithOption.embedding_options[:background_index].should == true
+    CommentWithLessOption.embedding_options[:background_index].should == false
+  end
+  
+end

data/spec/unit/shared_fields_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe "Mongoid::Mirrored" do
+
+  
+  context "Root Class" do
+    let(:comment) { Comment.new }
+    
+    it "should include shared fields with correct type and default definition" do
+      comment.fields.should have_key "author"
+      comment.fields.should have_key "contents"
+      comment.fields.should have_key "like_count"
+      comment.fields["like_count"].type.should == Integer
+      comment.fields["like_count"].default.should == 0
+    end
+  end
+  
+  context "Article::Comment Mirror Class" do
+    let(:mirror) { Article::Comment.new }
+    
+    it "should include shared fields with correct type and default definition" do
+      mirror.fields.should have_key "author"
+      mirror.fields.should have_key "contents"
+      mirror.fields.should have_key "like_count"
+      mirror.fields["like_count"].type.should == Integer
+      mirror.fields["like_count"].default.should == 0
+    end
+  end
+
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: mongoid-mirrored
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Alexandre Angelim
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-24 00:00:00 -03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mongoid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 6
+        version: "2.6"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bson_ext
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id003
+description: Create mirrors of root documents embeded in other models and keep them in sync
+email: angelim@angelim.com.br
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .document
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/mongoid-mirrored.rb
+- lib/mongoid-mirrored/helper_methods.rb
+- lib/mongoid-mirrored/mirror/mirror_methods.rb
+- 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
+- spec/functional/mongoid/comment_spec.rb
+- spec/models/article.rb
+- spec/models/comment.rb
+- spec/models/comment_with_less_option.rb
+- spec/models/comment_with_option.rb
+- spec/models/user.rb
+- spec/spec_helper.rb
+- spec/unit/associations_spec.rb
+- spec/unit/callback_specs.rb
+- spec/unit/index_spec.rb
+- spec/unit/options_spec.rb
+- spec/unit/shared_fields_spec.rb
+has_rdoc: true
+homepage: http://github.com/angelim/mongoid-mirrored
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: mongoid-mirrored
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Mirrored Embeds for Mongoid
+test_files: 
+- spec/functional/mongoid/comment_spec.rb
+- spec/models/article.rb
+- spec/models/comment.rb
+- spec/models/comment_with_less_option.rb
+- spec/models/comment_with_option.rb
+- spec/models/user.rb
+- spec/spec_helper.rb
+- spec/unit/associations_spec.rb
+- spec/unit/callback_specs.rb
+- spec/unit/index_spec.rb
+- spec/unit/options_spec.rb
+- spec/unit/shared_fields_spec.rb