mongoid_max_denormalize 0.0.2 → 0.0.3

data/README.md

@@ -6,8 +6,13 @@ 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
+* Denormalize fields
+* Denormalize methods (only in One to Many situations for now)
+* Denormalize `count` in Many to One situations
+* Propagate only when needed:
+    * for fields: when there are actual changes
+    * for methods: always (we can't know in an inexpensive way what is the old value to figure out if there is a change)
+* Take advantage of atomic operations on multiple documents of MongoDB
 
 *This is a pre-version not suitable for production.*
 
@@ -34,6 +39,13 @@ Add `include Mongoid::Max::Denormalize` in your model and also:
     denormalize relation, field_1, field_2 ... field_n, options
 
 
+### Warming up
+
+If there are existing records prior to the denormalization setup, you have to warm up. See below for each relation type.
+
+Note: you can't warm up from both sides of the relation. Only the most efficient is available.
+
+
 ### One to Many
 
 **Supported fields:** normal Mongoid fields, and methods.
@@ -58,7 +70,7 @@ Example :
       include Mongoid::Document
       include Mongoid::Max::Denormalize
 
-      belons_to :post
+      belongs_to :post
       denormalize :post, :title, :slug
     end
 
@@ -72,6 +84,10 @@ Example :
     @comment.post_title #=> "All Must Share The Burden"
     @comment.post_slug  #=> "all-must-share-the-burden"
 
+To warm up the denormalization for an existing collection:
+
+    Post.denormalize_to_comments!
+
 **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 ?
 
@@ -116,7 +132,7 @@ Example :
     class Comment
       include Mongoid::Document
 
-      belons_to :post
+      belongs_to :post
 
       field :rating
       field :stuff
@@ -130,10 +146,14 @@ Example :
     @post.comments_rating #=> [5, 3]
     @post.comments_stuff  #=> ["A", "B"]
 
+To warm up the denormalization for an existing collection:
+
+    Post.denormalize_from_comments!
+
 You can see that each denormalized field in stored in a separate array. This is wanted.
-An option `:group` will come to allow :
+An option `:group` will come to allow the way below (and maybe permit methods denormalization) :
 
-    @post.comments_fields #=> [{:rating => 5, :stuff => "A"},{:rating => 5, :stuff => "B"}]
+    @post.comments_fields #=> [{:rating => 5, :stuff => "A"}, {:rating => 5, :stuff => "B"}]
 
 
 ### Many to One
@@ -142,6 +162,16 @@ To come...
 
 
 
+## Planned
+
+* Support for Many to Many
+* Support for `:group` option in Many to One
+* Support for methods denormalization in Many to One (depends on `:group` option)
+* Support for `:sum` and `:mean` options in Many to One
+* Support for `:touch` option to "touch" an `updated_at` field (for cache purpose)
+
+
+
 ## Contributing
 
 Contributions and bug reports are welcome.

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

@@ -13,8 +13,34 @@ module Mongoid
           @inverse_meta = inverse_meta
           @fields = fields
           @options = options
+
+          verify
+        end
+
+        def verify
+          # There are fields
+          raise ConfigError.new("Nothing to denormalize", klass, relation) if fields.empty? && options.empty?
+
+          # All fields/methods are well defined
+          fields.each do |field|
+            unless meta.klass.instance_methods.include? field
+              raise ConfigError.new("Unknown field or method :#{field}", klass, relation)
+            end
+          end
+
+          # All options are allowed
+          unless unallowed_options.empty?
+            raise ConfigError.new("Unknown or not supported options :#{unallowed_options.first}", klass, relation)
+          end
         end
 
+        def allowed_options
+          []
+        end
+
+        def unallowed_options
+          options.keys - allowed_options
+        end
 
         def relation
           @meta.name

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

@@ -4,8 +4,8 @@ module Mongoid
     module Denormalize
       class ConfigError < ::StandardError
 
-        def initialize(summary, klass)
-          super("[#{klass}.denormalize] #{summary}")
+        def initialize(summary, klass, relation=nil)
+          super("[%s.denormalize%s] %s" % [klass, relation && " :#{relation}", summary])
         end
 
       end

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

@@ -5,10 +5,17 @@ module Mongoid
 
       class ManyToOne < Base
 
-        def attach
+        def verify
+          super
 
-          fields.each do |field|
-            klass.field "#{relation}_#{field}", type: Array
+          unless fields_methods.empty?
+            raise ConfigError.new("Methods denormalization not supported for Many to One", klass, relation)
+          end
+        end
+
+        def attach
+          fields_only.each do |field|
+            klass.field "#{relation}_#{field}", type: Array, default: []
           end
 
           if has_count?
@@ -16,26 +23,36 @@ module Mongoid
           end
 
           callback_code = <<EOM
-            before_save :denormalize_from_#{relation}
+            before_create :denormalize_from_#{relation}
 
-            def denormalize_from_#{relation}
-              return unless #{meta.key}_changed?
+            def denormalize_from_#{relation}(force=false)
+              #{relation}_retrieved = nil
 
-              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))
+              fields = [#{Base.array_code_for(fields_only)}]
+              unless fields.empty?
+                #{relation}_retrieved = #{relation}.unscoped.to_a
+                if #{relation}_retrieved.count > 0
+                  fields.each do |field|
+                    self.send(:"#{relation}_\#{field}=", #{relation}_retrieved.map(&field).compact)
+                  end
                 end
               end
 
+              if #{has_count?}
+                self.#{relation}_count = #{relation}_retrieved.nil? ? #{relation}.unscoped.count : #{relation}_retrieved.count
+              end
+
               true
             end
+
+            def self.denormalize_from_#{relation}!
+              each do |obj|
+                obj.denormalize_from_#{relation}(true)
+                obj.save!
+              end
+            end
 EOM
-          #klass.class_eval callback_code
+          klass.class_eval callback_code
 
           callback_code = <<EOM
             around_save :denormalize_to_#{inverse_relation}
@@ -74,6 +91,8 @@ EOM
                     end
                   end
                 end
+              elsif #{inverse_meta.key}.nil?
+                changed_fields = []
               else
                 changed_fields = fields & changed.map(&:to_sym)
                 changed_fields.each do |field|
@@ -82,11 +101,10 @@ EOM
                 end
               end
 
-              yield
+              yield if block_given?
               return if changed_fields.empty?
 
-              to_update = { "$set" => {}, "$inc" => {} }
-              to_push = {}
+              to_update = { "$set" => {}, "$inc" => {}, "$push" => {} }
               to_get = {}
 
               to_rem_fields = to_rem.reject {|k,v| v.nil?}.keys
@@ -94,7 +112,7 @@ EOM
 
               # Those to add only
               (to_add_only_fields = to_add_fields - to_rem_fields).each do |field|
-                to_push[field] = to_add[field]
+                to_update["$push"][field] = to_add[field]
               end
 
               to_set_fields = (to_add_fields + to_rem_fields - to_add_only_fields).uniq
@@ -116,14 +134,11 @@ EOM
                 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)
 
+              to_update.reject! {|k,v| v.empty?}
               #{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
@@ -136,7 +151,7 @@ EOM
                 to_rem[:"#{relation}_\#{field}"] = send(:"\#{field}_was")
               end
 
-              to_update = { "$set" => {}, "$inc" => {} }
+              to_update = { "$set" => {}, "$inc" => {}, "$push" => {} }
               to_get = {}
 
               to_rem_fields = to_rem.reject {|k,v| v.nil?}.keys
@@ -159,6 +174,7 @@ EOM
 
               to_update["$inc"][:#{relation}_count] = -1 if #{has_count?}
 
+              to_update.reject! {|k,v| v.empty?}
               #{klass}.collection.find(:_id => remote_id).update_all(to_update) unless to_update.empty?
             end
 
@@ -176,10 +192,9 @@ EOM
                 to_rem[:"#{relation}_\#{field}"] = send(field)
               end
 
-              yield
+              yield if block_given?
 
-              to_update = { "$set" => {}, "$inc" => {} }
-              to_push = {}
+              to_update = { "$set" => {}, "$inc" => {}, "$push" => {} }
               to_get = {}
 
               to_rem_fields = to_rem.reject {|k,v| v.nil?}.keys
@@ -199,12 +214,17 @@ EOM
 
               to_update["$inc"][:#{relation}_count] = -1 if #{has_count?}
 
+              to_update.reject! {|k,v| v.empty?}
               #{klass}.collection.find(:_id => remote_id).update_all(to_update) unless to_update.empty?
             end
 EOM
           meta.klass.class_eval callback_code
         end
 
+        def allowed_options
+          super + [:count]
+        end
+
         def has_count?
           !options[:count].nil?
         end

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

@@ -6,7 +6,6 @@ module Mongoid
       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)
@@ -37,15 +36,15 @@ EOM
           callback_code = <<EOM
             around_save :denormalize_to_#{inverse_relation}
 
-            def denormalize_to_#{inverse_relation}
-              return unless changed?
+            def denormalize_to_#{inverse_relation}(force = false)
+              return unless changed? || force
 
               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)
+              changed_fields = force ? fields_only.dup : (fields_only & changed.map(&:to_sym))
 
-              yield
+              yield if block_given?
 
               return if changed_fields.count == 0
 
@@ -57,12 +56,18 @@ EOM
               #{inverse_relation}.update to_set
             end
 
+            def self.denormalize_to_#{inverse_relation}!
+              each do |obj|
+                obj.denormalize_to_#{inverse_relation}(true)
+              end
+            end
+
             around_destroy :denormalize_to_#{inverse_relation}_destroy
 
             def denormalize_to_#{inverse_relation}_destroy
               fields = [#{Base.array_code_for(fields)}]
 
-              yield
+              yield if block_given?
 
               to_set = {}
               fields.each do |field|
@@ -73,9 +78,6 @@ EOM
             end
 EOM
           meta.klass.class_eval callback_code
-
-
-
         end
 
       end

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

@@ -4,7 +4,7 @@ module Mongoid
     module Denormalize
       module Version
 
-        STRING = '0.0.2'
+        STRING = '0.0.3'
 
       end
     end

data/lib/mongoid/max/denormalize.rb

@@ -20,26 +20,20 @@ module Mongoid
 #          puts "#options  : #{options.inspect}"
 
           meta = self.relations[relation.to_s]
-          raise ConfigError.new("Unknown relation :#{relation}", self) if meta.nil?
+          raise ConfigError.new("Unknown relation", self, relation) 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?
+          raise ConfigError.new("Unknown inverse relation", self, relation) 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)
+            raise ConfigError.new("Relation not supported", self, relation)
           end
 
         end

data/spec/cases/existing_models_spec.rb

@@ -0,0 +1,104 @@
+# encoding: utf-8
+require 'spec_helper'
+
+#
+# The case
+#
+class Author
+  include Mongoid::Document
+
+  field :name, type: String
+
+  has_many :books
+end
+
+class Book
+  include Mongoid::Document
+  include Mongoid::Max::Denormalize
+
+  field :name, type: String
+
+  def slug
+    name.try(:parameterize)
+  end
+
+  belongs_to :author
+
+  has_many :reviews
+end
+
+class Review
+  include Mongoid::Document
+  include Mongoid::Max::Denormalize
+
+  belongs_to :book
+
+  field :rating, type: Integer
+end
+
+def reload!
+  [@author, @book, @review_1, @review_2].each(&:reload)
+end
+
+#
+# The specs
+#
+describe "Case: Existing models" do
+  before(:each) do
+    @author = Author.create!(name: "Michael Crichton")
+    @book = Book.create!(name: "Jurassic Park", author: @author)
+    @review_1 = Review.create!(book: @book, rating: 4)
+    @review_2 = Review.create!(book: @book, rating: 5)
+
+    reload!
+  end
+
+  context "when defining the denormalization for Authors in Books" do
+    before { Book.denormalize :author, :name }
+
+    it "Authors denormalized fields should fill" do
+      @book.author_name.should be_nil
+
+      Author.denormalize_to_books!
+      reload!
+
+      @book.author_name.should eq("Michael Crichton")
+    end
+  end
+
+  context "when defining the denormalization for Books in Reviews" do
+    before { Review.denormalize :book, :name, :slug }
+
+    it "Books denormalized fields should fill" do
+      [@review_1, @review_2].each do |review|
+        review.book_name.should be_nil
+        review.book_slug.should be_nil
+      end
+
+      Book.denormalize_to_reviews!
+      reload!
+
+      [@review_1, @review_2].each do |review|
+        review.book_name.should eq("Jurassic Park")
+        review.book_slug.should eq("jurassic-park")
+      end
+    end
+  end
+
+  context "when defining the denormalization for Reviews in Books" do
+    before { Book.denormalize :reviews, :rating, :count => true }
+
+    it "Reviews denormalized fields should fill" do
+      @book.reviews_count.should be_nil
+      @book.reviews_rating.should be_nil
+
+      Book.denormalize_from_reviews!
+      reload!
+
+      @book.reviews_count.should eq 2
+      @book.reviews_rating.should eq [4, 5]
+    end
+  end
+
+end
+

data/spec/cases/{song_and_notes_spec.rb → song_and_ratings_spec.rb}

@@ -9,6 +9,7 @@ class Rating
 
   field :note, type: Integer
   field :comment, type: String
+  field :upset_level, type: Integer
 
   belongs_to :song
 end
@@ -19,7 +20,8 @@ class Song
 
   has_many :ratings
 
-  denormalize :ratings, :note, :comment, count: true, mean: [:note]
+  #denormalize :ratings, :note, :comment, count: true, mean: [:note]
+  denormalize :ratings, :note, :comment, :upset_level, count: true
 end
 
 
@@ -55,12 +57,12 @@ describe "Case: a song and his ratings" do
       its(:ratings_count) { should eq 1 }
       its(:ratings_note) { should eq [5] }
       its(:ratings_comment) { should eq ["Good!"] }
-
-#      its(:ratings_mean) { should eq 5 }
+      its(:ratings_upset_level) { should eq [] }
 
       context "when modifing the first rating (=4)" do
         before do
           @rating.note = 4
+          @rating.upset_level = 0
           @rating.save!
           @song.reload
         end
@@ -69,6 +71,7 @@ describe "Case: a song and his ratings" do
         its(:ratings_count) { should eq 1 }
         its(:ratings_note) { should eq [4] }
         its(:ratings_comment) { should eq ["Good!"] }
+        its(:ratings_upset_level) { should eq [0] }
       end
 
       context "when adding an other rating (=5)" do

data/spec/spec_helper.rb

@@ -18,6 +18,8 @@ RSpec.configure do |config|
 
   # Drop all collections and clear the identity map before each spec.
   config.before(:each) do
+    Moped.logger.info("\n  ### " << example.full_description)
+
     Mongoid.purge!
     Mongoid::IdentityMap.clear
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_max_denormalize
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -94,10 +94,10 @@ files:
 - lib/mongoid/max/denormalize/base.rb
 - lib/mongoid/max/denormalize.rb
 - spec/lib/mongoid_max_denormalize_spec.rb
-- spec/cases/existing_spec.rb
+- spec/cases/song_and_ratings_spec.rb
+- spec/cases/existing_models_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: []
@@ -125,8 +125,8 @@ specification_version: 3
 summary: MaxMapper, polyvalent ORM for Rails
 test_files:
 - spec/lib/mongoid_max_denormalize_spec.rb
-- spec/cases/existing_spec.rb
+- spec/cases/song_and_ratings_spec.rb
+- spec/cases/existing_models_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

data/spec/cases/existing_spec.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-#
-# The case
-#
-class Author
-  include Mongoid::Document
-
-  field :name, type: String
-
-  has_many :books
-end
-
-class Book
-  include Mongoid::Document
-  include Mongoid::Max::Denormalize
-
-  field :name, type: String
-
-  belongs_to :author
-
-  has_many :reviews
-end
-
-class Review
-  include Mongoid::Document
-  include Mongoid::Max::Denormalize
-
-  belongs_to :book
-
-  field :rating, type: Integer
-end
-
-#
-# The specs
-#
-describe "Case: Existing" do
-
-  before do
-    @author = Author.create!(name: "Michael Crichton")
-    @book = Book.create!(name: "Jurassic Park", author: @author)
-    @review_1 = Review.create!(book: @book, rating: 4)
-    @review_2 = Review.create!(book: @book, rating: 5)
-  end
-
-  context "when defining the denormalization" do
-    before do
-      Book.denormalize :author, :name
-      Book.denormalize :reviews, :rating, :count => true
-      Review.denormalize :book, :name
-    end
-
-    it "denormalization should be empty" do
-
-    end
-
-  end
-
-end
-