mongoid_max_denormalize 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Maxime Garcia
+
+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,157 @@
+# Mongoid::Max::Denormalize
+
+`Mongoid::Max::Denormalize` is a denormalization extension for Mongoid.
+
+It was designed for a minimum number of queries to the database.
+
+For now, support only Mongoid 3.
+
+* Propagate only when needed
+* Take advantage of atomic operations on multi documents of MongoDB
+
+
+
+## Installation
+
+Add the gem to your Gemfile:
+
+    gem 'mongoid_max_denormalize'
+
+Or install with RubyGems:
+
+    $ gem install mongoid_max_denormalize
+
+
+
+## Usage
+
+### Basic usage
+
+Add `include Mongoid::Max::Denormalize` in your model and also:
+
+      denormalize relation, field_1, field_2 ... field_n, options
+
+
+### One to Many
+
+Supported fields: normal Mongoid fields, and methods.
+
+Supported options: none.
+
+Example :
+
+    class Post
+      include Mongoid::Document
+      field :title
+      def slug
+        title.try(:parameterize)
+      end
+      has_many :comments
+    end
+
+    class Comment
+      include Mongoid::Document
+      include Mongoid::Max::Denormalize
+      belons_to :post
+      denormalize :post, :title, :slug
+    end
+
+    @post = Post.create(:title => "Mush from the Wimp")
+    @comment = @post.comments.create
+    @comment.post_title #=> "Mush from the Wimp"
+    @comment.post_slug  #=> "mush-from-the-wimp"
+    #
+    @post.update_attributes(:title => "All Must Share The Burden")
+    @comment.reload     # to reload the comment from the DB
+    @comment.post_title #=> "All Must Share The Burden"
+    @comment.post_slug  #=> "all-must-share-the-burden"
+
+**Tips :** In your views, do not use `@comment.post` but `@comment.post_id` or `@comment.post_id?`
+to avoid a query that checks/retrieve for the post. We want to avoid it, don't we ?
+
+Exemple : Check your logs, you'll see queries for the post :
+
+    # app/views/comments/_comment.html.erb
+    <div class="comment">
+      <% if @comment.post %>
+        <%= link_to @comment.post_title, @comment.post %>
+      <% end %>
+    </div>
+
+This is better :
+
+    # app/views/comments/_comment.html.erb
+    <div class="comment">
+      <% if @comment.post_id? %>
+        <%= link_to @comment.post_title, post_path(@comment.post_id, :slug => @comment.post_slug) %>
+      <% end %>
+    </div>
+
+
+### Many to One
+
+Supported fields: **only** normal Mongoid fields (no methods)
+
+Supported options:
+
+*   `:count => true` : to keep a count !
+
+
+Example :
+
+    class Post
+      include Mongoid::Document
+      include Mongoid::Max::Denormalize
+      has_many :comments
+      denormalize :comments, :rating, :stuff, :count => true
+    end
+
+    class Comment
+      include Mongoid::Document
+      belons_to :post
+      field :rating
+      field :stuff
+    end
+
+    @post = Post.create(:title => "J'accuse !")
+    @comment = @post.comments.create(:rating => 5, :stuff => "A")
+    @comment = @post.comments.create(:rating => 3, :stuff => "B")
+    @post.reload
+    @post.comments_count #=> 2
+    @post.comments_rating #=> [5, 3]
+    @post.comments_stuff #=> ["A", "B"]
+
+You can see that each denormalized field in stored in a separate array. This is wanted.
+An option `:group` will come to allow :
+
+    @post.comments_fields #=> [{:rating => 5, :stuff => "A"},{:rating => 5, :stuff => "B"}]
+
+
+### Many to One
+
+To come...
+
+
+
+## Contributing
+
+Contributions and bug reports are welcome.
+
+Clone the repository and run `bundle install` to setup the development environment.
+
+Provide a case spec according to your changes/needs, taking example on existing ones (in `spec/cases`).
+
+To run the specs:
+
+    bundle exec rspec
+
+
+
+## Credits
+
+*   Maxime Garcia [emaxime.com](http://emaxime.com) [@maximegarcia](http://twitter.com/maximegarcia)
+
+
+[License](https://github.com/maximeg/mongoid_max_denormalize/blob/master/LICENSE)
+\- [Report a bug](https://github.com/maximeg/mongoid_max_denormalize/issues).
+

data/lib/mongoid/max/denormalize/base.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Mongoid
+  module Max
+    module Denormalize
+
+      class Base
+
+        attr_accessor :klass, :meta, :inverse_meta, :fields, :options
+
+        def initialize(klass, meta, inverse_meta, fields, options)
+          @klass = klass
+          @meta = meta
+          @inverse_meta = inverse_meta
+          @fields = fields
+          @options = options
+        end
+
+
+        def relation
+          @meta.name
+        end
+        def inverse_relation
+          @meta.inverse
+        end
+        def inverse_klass
+          @meta.klass
+        end
+
+
+        def fields_methods
+          @fields_methods ||= fields.select do |field|
+            meta.klass.fields[field.to_s].nil?
+          end
+        end
+        def fields_only
+          @fields_only ||= fields - fields_methods
+        end
+
+        class << self
+
+          def array_code_for(fields)
+            fields.map { |field| ":#{field}" }.join(", ")
+          end
+
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/mongoid/max/denormalize/config_error.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Mongoid
+  module Max
+    module Denormalize
+      class ConfigError < ::StandardError
+
+        def initialize(summary, klass)
+          super("[#{klass}.denormalize] #{summary}")
+        end
+
+      end
+    end
+  end
+end
+

data/lib/mongoid/max/denormalize/many_to_one.rb

@@ -0,0 +1,218 @@
+# encoding: utf-8
+module Mongoid
+  module Max
+    module Denormalize
+
+      class ManyToOne < Base
+
+        def attach
+
+          fields.each do |field|
+            klass.field "#{relation}_#{field}", type: Array
+          end
+
+          if has_count?
+            klass.field "#{relation}_count", type: Integer, default: 0
+          end
+
+          callback_code = <<EOM
+            before_save :denormalize_from_#{relation}
+
+            def denormalize_from_#{relation}
+              return unless #{meta.key}_changed?
+
+              fields = [#{Base.array_code_for(fields)}]
+              if #{meta.key}.nil?
+                fields.each do |field|
+                  self.send(:"#{relation}_\#{field}=", nil)
+                end
+              else
+                fields.each do |field|
+                  self.send(:"#{relation}_\#{field}=", #{relation}.send(field))
+                end
+              end
+
+              true
+            end
+EOM
+          #klass.class_eval callback_code
+
+          callback_code = <<EOM
+            around_save :denormalize_to_#{inverse_relation}
+
+            def denormalize_to_#{inverse_relation}
+              return if !changed? && !new_record?
+              was_new = new_record?
+              was_added = false
+              was_removed = false
+
+              fields = [#{Base.array_code_for(fields_only)}]
+
+              remote_id = send(:#{inverse_meta.key})
+
+              to_rem = {}
+              to_add = {}
+              if #{inverse_meta.key}_changed?
+                changed_fields = fields
+                if !#{inverse_meta.key}.nil? && !#{inverse_meta.key}_was.nil?
+                  was_added = true
+                  changed_fields.each do |field|
+                    to_add[:"#{relation}_\#{field}"] = send(field)
+                  end
+                  denormalize_to_#{inverse_relation}_old
+                else
+                  if #{inverse_meta.key}_was.nil?
+                    was_added = true
+                    changed_fields.each do |field|
+                      to_add[:"#{relation}_\#{field}"] = send(:"\#{field}_changed?") ? send(field) : send(:"\#{field}_was")
+                    end
+                  else
+                    was_removed = true
+                    remote_id = send(:#{inverse_meta.key}_was)
+                    changed_fields.each do |field|
+                      to_rem[:"#{relation}_\#{field}"] = send(:"\#{field}_changed?") ? send(:"\#{field}_was") : send(field)
+                    end
+                  end
+                end
+              else
+                changed_fields = fields & changed.map(&:to_sym)
+                changed_fields.each do |field|
+                  to_rem[:"#{relation}_\#{field}"] = send(:"\#{field}_was")
+                  to_add[:"#{relation}_\#{field}"] = send(field)
+                end
+              end
+
+              yield
+              return if changed_fields.empty?
+
+              to_update = { "$set" => {}, "$inc" => {} }
+              to_push = {}
+              to_get = {}
+
+              to_rem_fields = to_rem.reject {|k,v| v.nil?}.keys
+              to_add_fields = to_add.reject {|k,v| v.nil?}.keys
+
+              # Those to add only
+              (to_add_only_fields = to_add_fields - to_rem_fields).each do |field|
+                to_push[field] = to_add[field]
+              end
+
+              to_set_fields = (to_add_fields + to_rem_fields - to_add_only_fields).uniq
+
+              to_get.merge! Hash[to_set_fields.map{ |f| [f, 1] }] unless to_set_fields.empty?
+
+              obj = #{klass}.collection.find("$query" => {:_id => remote_id}, "$only" => to_get).first unless to_get.empty?
+
+              to_set_fields.each do |field|
+                array = obj[field.to_s] || []
+
+                if to_rem_fields.include? field
+                  (i = array.index(to_rem[field])) and array.delete_at(i)
+                end
+                if to_add_fields.include? field
+                  array << to_add[field]
+                end
+
+                to_update["$set"][field] = array
+              end
+
+
+              to_update["$inc"][:#{relation}_count] = 1 if #{has_count?} && (was_new || was_added)
+              to_update["$inc"][:#{relation}_count] = -1 if #{has_count?} && (was_removed)
+
+              #{klass}.collection.find(:_id => remote_id).update_all(to_update) unless to_update.empty?
+
+
+              #{klass}.collection.find(:_id => remote_id).update_all({"$push" => to_push}) unless to_push.empty?
+            end
+
+            def denormalize_to_#{inverse_relation}_old
+              fields = [#{Base.array_code_for(fields_only)}]
+
+              remote_id = send(:#{inverse_meta.key}_was)
+
+              to_rem = {}
+              fields.each do |field|
+                to_rem[:"#{relation}_\#{field}"] = send(:"\#{field}_was")
+              end
+
+              to_update = { "$set" => {}, "$inc" => {} }
+              to_get = {}
+
+              to_rem_fields = to_rem.reject {|k,v| v.nil?}.keys
+
+              to_set_fields = to_rem_fields
+
+              to_get.merge! Hash[to_set_fields.map{ |f| [f, 1] }] unless to_set_fields.empty?
+
+              obj = #{klass}.collection.find("$query" => {:_id => remote_id}, "$only" => to_get).first unless to_get.empty?
+
+              to_set_fields.each do |field|
+                array = obj[field.to_s] || []
+
+                if to_rem_fields.include? field
+                  (i = array.index(to_rem[field])) and array.delete_at(i)
+                end
+
+                to_update["$set"][field] = array
+              end
+
+              to_update["$inc"][:#{relation}_count] = -1 if #{has_count?}
+
+              #{klass}.collection.find(:_id => remote_id).update_all(to_update) unless to_update.empty?
+            end
+
+
+
+            around_destroy :denormalize_to_#{inverse_relation}_destroy
+
+            def denormalize_to_#{inverse_relation}_destroy
+              fields = [#{Base.array_code_for(fields)}]
+
+              remote_id = send(:#{inverse_meta.key})
+
+              to_rem = {}
+              fields.each do |field|
+                to_rem[:"#{relation}_\#{field}"] = send(field)
+              end
+
+              yield
+
+              to_update = { "$set" => {}, "$inc" => {} }
+              to_push = {}
+              to_get = {}
+
+              to_rem_fields = to_rem.reject {|k,v| v.nil?}.keys
+
+              to_get.merge! Hash[to_rem_fields.map{ |f| [f, 1] }]
+              obj = #{klass}.collection.find("$query" => {:_id => remote_id}, "$only" => to_get).first unless to_get.empty?
+
+              to_rem_fields.each do |field|
+                array = obj[field.to_s] || []
+
+                if to_rem_fields.include? field
+                  (i = array.index(to_rem[field])) and array.delete_at(i)
+                end
+
+                to_update["$set"][field] = array
+              end
+
+              to_update["$inc"][:#{relation}_count] = -1 if #{has_count?}
+
+              #{klass}.collection.find(:_id => remote_id).update_all(to_update) unless to_update.empty?
+            end
+EOM
+          meta.klass.class_eval callback_code
+          puts callback_code
+        end
+
+        def has_count?
+          !options[:count].nil?
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/mongoid/max/denormalize/one_to_many.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+module Mongoid
+  module Max
+    module Denormalize
+
+      class OneToMany < Base
+
+        def attach
+
+          fields.each do |field|
+            field_meta = meta.klass.fields[field.to_s]
+            klass.field "#{relation}_#{field}", type: field_meta.try(:type)
+          end
+
+          callback_code = <<EOM
+            before_save :denormalize_from_#{relation}
+
+            def denormalize_from_#{relation}
+              return unless #{meta.key}_changed?
+
+              fields = [#{Base.array_code_for(fields)}]
+              if #{meta.key}.nil?
+                fields.each do |field|
+                  self.send(:"#{relation}_\#{field}=", nil)
+                end
+              else
+                fields.each do |field|
+                  self.send(:"#{relation}_\#{field}=", #{relation}.send(field))
+                end
+              end
+
+              true
+            end
+EOM
+          klass.class_eval callback_code
+
+          callback_code = <<EOM
+            around_save :denormalize_to_#{inverse_relation}
+
+            def denormalize_to_#{inverse_relation}
+              return unless changed?
+
+              fields = [#{Base.array_code_for(fields)}]
+              fields_only = [#{Base.array_code_for(fields_only)}]
+              methods = [#{Base.array_code_for(fields_methods)}]
+              changed_fields = fields_only & changed.map(&:to_sym)
+
+              yield
+
+              return if changed_fields.count == 0
+
+              to_set = {}
+              (changed_fields + methods).each do |field|
+                to_set[:"#{relation}_\#{field}"] = send(field)
+              end
+
+              #{inverse_relation}.update to_set
+            end
+
+            around_destroy :denormalize_to_#{inverse_relation}_destroy
+
+            def denormalize_to_#{inverse_relation}_destroy
+              fields = [#{Base.array_code_for(fields)}]
+
+              yield
+
+              to_set = {}
+              fields.each do |field|
+                to_set[:"#{relation}_\#{field}"] = nil
+              end
+
+              #{inverse_relation}.update to_set
+            end
+EOM
+          meta.klass.class_eval callback_code
+
+
+
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/mongoid/max/denormalize/version.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid
+  module Max
+    module Denormalize
+      module Version
+
+        STRING = '0.0.1'
+
+      end
+    end
+  end
+end
+

data/lib/mongoid/max/denormalize.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Mongoid
+  module Max
+    module Denormalize
+      extend ActiveSupport::Concern
+
+      included do
+
+      end
+
+      module ClassMethods
+
+        def denormalize(relation, *fields)
+          options = fields.extract_options!
+
+          #TODO make all real fields if fields.empty?
+
+#          puts "#relation : #{relation.inspect}"
+#          puts "#fields   : #{fields.inspect}"
+#          puts "#options  : #{options.inspect}"
+
+          meta = self.relations[relation.to_s]
+          raise ConfigError.new("Unknown relation :#{relation}", self) if meta.nil?
+#          puts "#        meta : #{meta.inspect}"
+
+          inverse_meta = meta.klass.relations[meta.inverse.to_s]
+          raise ConfigError.new("Unknown inverse relation for :#{relation}", self) if inverse_meta.nil?
+#          puts "#inverse_meta : #{inverse_meta.inspect}"
+
+          methods = []
+          fields.each do |field|
+            unless meta.klass.instance_methods.include? field
+              raise ConfigError.new("Unknown field or method :#{field} in :#{relation}", self)
+            end
+          end
+
+          if meta.relation == Mongoid::Relations::Referenced::In && inverse_meta.relation == Mongoid::Relations::Referenced::Many
+            OneToMany.new(self, meta, inverse_meta, fields, options).attach
+          elsif meta.relation == Mongoid::Relations::Referenced::Many && inverse_meta.relation == Mongoid::Relations::Referenced::In
+            ManyToOne.new(self, meta, inverse_meta, fields, options).attach
+          else
+            raise ConfigError.new("Relation not supported :#{relation}", self)
+          end
+
+        end
+
+      end
+
+    end
+  end
+end
+

data/lib/mongoid_max_denormalize.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'active_support/core_ext'
+
+require 'mongoid/max/denormalize'
+require 'mongoid/max/denormalize/config_error'
+
+require 'mongoid/max/denormalize/base'
+require 'mongoid/max/denormalize/one_to_many'
+require 'mongoid/max/denormalize/many_to_one'
+

data/spec/cases/contact_and_addresses_spec.rb

@@ -0,0 +1,82 @@
+# encoding: utf-8
+require 'spec_helper'
+
+#
+# The case
+#
+class Contact
+  include Mongoid::Document
+
+  field :name, type: String
+
+  has_many :addresses
+end
+
+class Person < Contact
+end
+
+class Address
+  include Mongoid::Document
+  include Mongoid::Max::Denormalize
+
+  belongs_to :contact
+
+  denormalize :contact, :name
+end
+
+#
+# The specs
+#
+describe "Case: a contact and his addresses" do
+
+  before do
+    @person = Person.create!(name: "John Doe")
+  end
+
+  context "when nothing" do
+    context "considering the person" do
+      subject { @person }
+
+      its(:addresses) { should be_empty }
+    end
+  end
+
+  context "when adding a first address" do
+    before do
+      @address = @person.addresses.create!
+    end
+
+    context "considering the person" do
+      subject { @person }
+
+      its(:addresses) { should have(1).address }
+    end
+
+    context "considering the address" do
+      subject { @address }
+
+      its(:contact_name) { should eq @person.name }
+
+      context "when changing the person name" do
+        before do
+          @person.name = "John Doe Jr."
+          @person.save!
+          @address.reload
+        end
+
+        its(:contact_name) { should eq @person.name }
+      end
+
+      context "when destroying the person" do
+        before do
+          @person.destroy
+          @address.reload
+        end
+
+        its(:contact_name) { should be_nil }
+      end
+    end
+  end
+
+end
+

data/spec/cases/post_and_comments_spec.rb

@@ -0,0 +1,158 @@
+# encoding: utf-8
+require 'spec_helper'
+
+#
+# The case
+#
+class Post
+  include Mongoid::Document
+
+  field :title, type: String
+
+  def slug
+    title.try(:parameterize)
+  end
+
+  has_many :comments
+end
+
+class Comment
+  include Mongoid::Document
+  include Mongoid::Max::Denormalize
+
+  belongs_to :post
+
+  denormalize :post, :title, :slug
+end
+
+#
+# The specs
+#
+describe "Case: a post and his comments" do
+
+  before do
+    @post = Post.create!(title: "A good title !")
+  end
+
+  context "when nothing" do
+    context "considering the post" do
+      subject { @post }
+
+      its(:comments) { should be_empty }
+    end
+  end
+
+  comments_number = 2
+  context "when adding #{comments_number} comments" do
+    before do
+      @comments = []
+      comments_number.times do
+        @comments << @post.comments.create!
+      end
+    end
+
+    context "considering the post" do
+      subject { @post }
+
+      its(:comments) { should have(comments_number).comment }
+    end
+
+    (0..comments_number-1).each do |i|
+      context "considering the comment #{i}" do
+        subject { @comments[i] }
+
+        its(:post_title) { should eq @post.title }
+        its(:post_slug) { should eq @post.slug }
+      end
+    end
+
+    context "when changing the post title" do
+      before do
+        @post.title = "A new title !"
+        @post.save!
+        @comments.each(&:reload)
+      end
+
+      (0..comments_number-1).each do |i|
+        context "considering the comment #{i}" do
+          subject { @comments[i] }
+
+          its(:post_title) { should eq @post.title }
+          its(:post_slug) { should eq @post.slug }
+        end
+      end
+    end
+
+    context "when destroying the post" do
+      before do
+        @post.destroy
+        @comments.each(&:reload)
+      end
+
+      (0..comments_number-1).each do |i|
+        context "considering the comment #{i}" do
+          subject { @comments[i] }
+
+          its(:post_title) { should be_nil }
+          its(:post_slug) { should be_nil }
+        end
+      end
+    end
+  end
+
+  context "when creating a comment without associating it" do
+    before do
+      @comment_only = Comment.create!
+      @post.reload
+    end
+
+    subject { @comment_only }
+
+    its(:post_title) { should be_nil }
+    its(:post_slug) { should be_nil }
+
+    context "when associating it" do
+      before do
+        @comment_only.post = @post
+        @comment_only.save!
+      end
+
+      its(:post_title) { should eq @post.title }
+      its(:post_slug) { should eq @post.slug }
+    end
+
+    context "when associating it (2nd way)" do
+      before do
+        @post.comments << @comment_only
+        @comment_only.reload
+      end
+
+      its(:post_title) { should eq @post.title }
+      its(:post_slug) { should eq @post.slug }
+    end
+  end
+
+  context "when has a comment" do
+    before do
+      @comment = @post.comments.create!
+    end
+
+    subject { @comment }
+
+    its(:post_title) { should eq @post.title }
+    its(:post_slug) { should eq @post.slug }
+
+    context "when associating the comment to another post" do
+      before do
+        @other_post = Post.create!(title: "Another title.")
+        @comment.post = @other_post
+        @comment.save
+      end
+
+      its(:post_title) { should eq @other_post.title }
+      its(:post_slug) { should eq @other_post.slug }
+    end
+  end
+
+end
+

data/spec/cases/song_and_notes_spec.rb

@@ -0,0 +1,202 @@
+# encoding: utf-8
+require 'spec_helper'
+
+#
+# The case
+#
+class Rating
+  include Mongoid::Document
+
+  field :note, type: Integer
+  field :comment, type: String
+
+  belongs_to :song
+end
+
+class Song
+  include Mongoid::Document
+  include Mongoid::Max::Denormalize
+
+  has_many :ratings
+
+  denormalize :ratings, :note, :comment, count: true, mean: [:note]
+end
+
+
+#
+# The specs
+#
+describe "Case: a song and his ratings" do
+
+  before do
+    @song = Song.create!
+  end
+
+  context "when nothing" do
+    context "considering the song" do
+      subject { @song }
+
+      it "should not have ratings" do
+        @song.ratings.should be_empty
+      end
+    end
+  end
+
+  context "when adding a first rating (=5)" do
+    before do
+      @rating = @song.ratings.create!(note: 5, comment: "Good!")
+      @song.reload
+    end
+
+    context "considering the song" do
+      subject { @song }
+
+      its(:ratings) { should have(1).rating }
+      its(:ratings_count) { should eq 1 }
+      its(:ratings_note) { should eq [5] }
+      its(:ratings_comment) { should eq ["Good!"] }
+
+#      its(:ratings_mean) { should eq 5 }
+
+      context "when modifing the first rating (=4)" do
+        before do
+          @rating.note = 4
+          @rating.save!
+          @song.reload
+        end
+
+        its(:ratings) { should have(1).rating }
+        its(:ratings_count) { should eq 1 }
+        its(:ratings_note) { should eq [4] }
+        its(:ratings_comment) { should eq ["Good!"] }
+      end
+
+      context "when adding an other rating (=5)" do
+        before do
+          @other_rating = @song.ratings.create!(note: 5, comment: "Another good!")
+          @song.reload
+        end
+
+        its(:ratings) { should have(2).rating }
+        its(:ratings_count) { should eq 2 }
+        its(:ratings_note) { should eq [5, 5] }
+        its(:ratings_comment) { should eq ["Good!", "Another good!"] }
+
+        context "when modifing the first rating (=4)" do
+          before do
+            @rating.note = 4
+            @rating.save!
+            @song.reload
+          end
+
+          its(:ratings_count) { should eq 2 }
+          its(:ratings_note) { should eq [5, 4] }
+          its(:ratings_comment) { should eq ["Good!", "Another good!"] }
+        end
+
+        context "when modifing the other rating (=4)" do
+          before do
+            @other_rating.note = 4
+            @other_rating.save!
+            @song.reload
+          end
+
+          its(:ratings_count) { should eq 2 }
+          its(:ratings_note) { should eq [5, 4] }
+          its(:ratings_comment) { should eq ["Good!", "Another good!"] }
+
+          context "when modifing again the other rating (=3)" do
+            before do
+              @other_rating.note = 3
+              @other_rating.comment = "Another good, again!"
+              @other_rating.save!
+              @song.reload
+            end
+
+            its(:ratings_count) { should eq 2 }
+            its(:ratings_note) { should eq [5, 3] }
+            its(:ratings_comment) { should eq ["Good!", "Another good, again!"] }
+          end
+        end
+
+        context "when destroying the other rating" do
+          before do
+            @other_rating.destroy
+            @song.reload
+          end
+
+          its(:ratings_count) { should eq 1 }
+          its(:ratings) { should have(1).rating }
+          its(:ratings_note) { should eq [5] }
+          its(:ratings_comment) { should eq ["Good!"] }
+        end
+      end
+
+      context "when creating a rating (=1) without associating it" do
+        before do
+          @rating_only = Rating.create!(note: 1, comment: "Bad")
+          @song.reload
+        end
+
+        its(:ratings) { should have(1).rating }
+        its(:ratings_count) { should eq 1 }
+        its(:ratings_note) { should eq [5] }
+        its(:ratings_comment) { should eq ["Good!"] }
+
+        context "when associating it" do
+          before do
+            @rating_only.song = @song
+            @rating_only.save!
+            @song.reload
+          end
+
+          its(:ratings) { should have(2).rating }
+          its(:ratings_count) { should eq 2 }
+          its(:ratings_note) { should eq [5, 1] }
+          its(:ratings_comment) { should eq ["Good!", "Bad"] }
+        end
+
+        context "when associating it (2nd way)" do
+          before do
+            @song.ratings << @rating_only
+            @song.reload
+          end
+
+          its(:ratings) { should have(2).rating }
+          its(:ratings_count) { should eq 2 }
+          its(:ratings_note) { should eq [5, 1] }
+          its(:ratings_comment) { should eq ["Good!", "Bad"] }
+        end
+      end
+
+      context "when associating to another song" do
+        before do
+          @other_song = Song.create!
+          @rating.song = @other_song
+          @rating.save!
+          @song.reload
+        end
+
+        its(:ratings) { should have(0).rating }
+        its(:ratings_count) { should eq 0 }
+        its(:ratings_note) { should eq [] }
+        its(:ratings_comment) { should eq [] }
+
+        context "considering the other song" do
+          before do
+            @other_song.reload
+          end
+
+          subject { @other_song }
+
+          its(:ratings) { should have(1).rating }
+          its(:ratings_count) { should eq 1 }
+          its(:ratings_note) { should eq [5] }
+          its(:ratings_comment) { should eq ["Good!"] }
+        end
+      end
+    end
+  end
+
+end
+

data/spec/lib/mongoid_max_denormalize_spec.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+
+require 'spec_helper'
+

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+require 'rubygems'
+require 'rspec'
+require 'mongoid'
+require 'mongoid_max_denormalize'
+require 'logger'
+
+Mongoid.configure do |config|
+  config.connect_to('mongoid_max_denormalize_test')
+end
+
+Mongoid.logger = Logger.new("log/mongoid-test.log")
+Mongoid.logger.level = Logger::DEBUG
+Moped.logger = Logger.new("log/moped-test.log")
+Moped.logger.level = Logger::DEBUG
+
+RSpec.configure do |config|
+
+  # Drop all collections and clear the identity map before each spec.
+  config.before(:each) do
+    Mongoid.purge!
+    Mongoid::IdentityMap.clear
+  end
+
+end
+

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: mongoid_max_denormalize
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Maxime Garcia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0.rc
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ! '    Mongoid::Max::Denormalize is a denormalization extension for Mongoid.
+
+'
+email:
+- maxime.garcia@maxbusiness.fr
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- LICENSE
+- lib/mongoid_max_denormalize.rb
+- lib/mongoid/max/denormalize/one_to_many.rb
+- lib/mongoid/max/denormalize/config_error.rb
+- lib/mongoid/max/denormalize/version.rb
+- lib/mongoid/max/denormalize/many_to_one.rb
+- lib/mongoid/max/denormalize/base.rb
+- lib/mongoid/max/denormalize.rb
+- spec/lib/mongoid_max_denormalize_spec.rb
+- spec/cases/contact_and_addresses_spec.rb
+- spec/cases/post_and_comments_spec.rb
+- spec/cases/song_and_notes_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/maximeg/mongoid_max_denormalize
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: MaxMapper, polyvalent ORM for Rails
+test_files:
+- spec/lib/mongoid_max_denormalize_spec.rb
+- spec/cases/contact_and_addresses_spec.rb
+- spec/cases/post_and_comments_spec.rb
+- spec/cases/song_and_notes_spec.rb
+- spec/spec_helper.rb