mongoid_alize 0.2.0 → 0.3.1

data/spec/mongoid/alize/instance_helpers_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Mongoid::Alize::InstanceHelpers do
+
+  def from_klass
+    Mongoid::Alize::Callbacks::From::One
+  end
+
+  def to_klass
+    Mongoid::Alize::ToCallback
+  end
+
+  before do
+    @head =
+      Head.new(person:
+               @person = Person.create(:name => @name = "Bob"))
+  end
+
+  describe "#denormalize_from_all" do
+    it "should run the alize callbacks" do
+      Head.alize_from_callbacks <<
+          callback = from_klass.new(Head, :person, [:name])
+      mock(@head).denormalize_from_person
+      @head.denormalize_from_all
+    end
+  end
+
+  describe "#denormalize_to_all" do
+    it "should run the alize callbacks" do
+      Person.alize_to_callbacks <<
+          callback = to_klass.new(Person, :head, [:size])
+      mock(@person).denormalize_to_head
+      @person.denormalize_to_all
+    end
+  end
+end

data/spec/mongoid/alize/macros_spec.rb

@@ -1,64 +1,137 @@
 require 'spec_helper'
 
 describe Mongoid::Alize::Macros do
-  describe "#alize" do
+  def person_default_fields
+    ["name", "created_at", "want_ids", "seen_by_id"]
+  end
+
+  def head_default_fields
+    ["size", "weight", "person_id", "captor_id", "wanted_by_ids"]
+  end
+
+  describe "#alize_to and #alize_from" do
     describe "with a belongs_to" do
       it_should_set_callbacks(Head, Person,
                              :person, :head,
-                             fns::One, tns::OneFromOne)
+                             fns::One, tns)
     end
 
     describe "with a has_one" do
       it_should_set_callbacks(Person, Head,
                              :head, :person,
-                             fns::One, tns::OneFromOne)
+                             fns::One, tns)
     end
 
     describe "with a has_many from the belongs_to side" do
       it_should_set_callbacks(Head, Person,
                              :captor, :heads,
-                             fns::One, tns::OneFromMany)
+                             fns::One, tns)
     end
 
     describe "with a has_many from the has_many side" do
       it_should_set_callbacks(Head, Person,
                              :sees, :seen_by,
-                             fns::Many, tns::ManyFromOne)
+                             fns::Many, tns)
     end
 
     describe "with a has_and_belongs_to_many" do
       it_should_set_callbacks(Head, Person,
                              :wanted_by, :wants,
-                             fns::Many, tns::ManyFromMany)
+                             fns::Many, tns)
     end
 
-    describe "when no inverse is present" do
-      it "should add only a from and not a to callback" do
-        dont_allow(Mongoid::Alize::Callbacks::To::OneFromOne).new
-        Head.alize(:admirer)
+    describe "#alize" do
+      it "should call alize_from" do
+        mock(Head).alize_from(:person, :name)
+        Head.alize(:person, :name)
+      end
+
+      it "should call alize_to if relation is not polymorphic" do
+        mock(Person).alize_to(:head, :name)
+        Head.alize(:person, :name)
+      end
+
+      describe "with a polymorphic association" do
+        it "should attach an inverse callback to the parent side" do
+          Person.relations["nearest_head"].should be_polymorphic
+          Person.relations["nearest_head"].should_not be_stores_foreign_key
+          Person.relations["nearest_head"].klass.should == Head
+          mock.proxy(Mongoid::Alize::ToCallback).new(Head, :nearest, head_default_fields)
+          Person.alize(:nearest_head)
+        end
+
+        it "should not attach a callback on the child side" do
+          Head.relations["nearest"].should be_polymorphic
+          Head.relations["nearest"].should be_stores_foreign_key
+          dont_allow(Mongoid::Alize::ToCallback).new
+          Head.alize(:nearest)
+        end
+      end
+
+      describe "when no inverse is present" do
+        it "should add only a from callback" do
+          Head.relations["admirer"].inverse.should be_nil
+          dont_allow(Mongoid::Alize::ToCallback).new
+          Head.alize(:admirer)
+        end
       end
     end
 
-    describe "fields" do
+    describe "#alize_to" do
       describe "with fields supplied" do
         it "should use them" do
-          dont_allow(Head).default_alize_fields
-          Head.alize(:person, :name)
+          mock.proxy(Mongoid::Alize::ToCallback).new(Person, :head, [:foo, :bar])
+          Person.alize_to(:head, :foo, :bar)
         end
       end
 
       describe "with no fields supplied" do
         it "should use the default alize fields" do
-          mock(Head).default_alize_fields(:person) { [:name] }
-          Head.alize(:person)
+          mock.proxy(Mongoid::Alize::ToCallback).new(Person, :head, person_default_fields)
+          Person.alize_to(:head)
+        end
+      end
+
+      describe "with a block supplied" do
+        it "should use the block supplied as fields in the options hash" do
+          blk = lambda {}
+          mock.proxy(Mongoid::Alize::ToCallback).new(Person, :head, blk)
+          Person.alize_to(:head, :foo, :fields => blk)
+        end
+      end
+    end
+
+    describe "#alize_from" do
+      describe "with fields supplied" do
+        it "should use them" do
+          mock.proxy(Mongoid::Alize::Callbacks::From::One).new(
+            Head, :person, [:foo, :bar])
+          Head.alize_from(:person, :foo, :bar)
+        end
+      end
+
+      describe "with no fields supplied" do
+        it "should use the default alize fields" do
+          mock.proxy(Mongoid::Alize::Callbacks::From::One).new(
+            Head, :person, person_default_fields)
+          Head.alize_from(:person)
+        end
+      end
+
+      describe "with a block supplied" do
+        it "should use the block supplied as fields in the options hash" do
+          blk = lambda {}
+          mock.proxy(Mongoid::Alize::Callbacks::From::One).new(
+            Head, :person, blk)
+          Head.alize_from(:person, :foo, :fields => blk)
         end
       end
     end
 
     describe "default_alize_fields" do
       it "should return an array of all non-internal field names (e.g. not _type or _id)" do
-        Head.default_alize_fields(:person).should ==
-          ["name", "created_at", "want_ids", "seen_by_id"]
+        Head.default_alize_fields.should == head_default_fields
+        Person.default_alize_fields.should == person_default_fields
       end
     end
   end

data/spec/mongoid/alize/to_callback_spec.rb

@@ -1,38 +1,59 @@
 require 'spec_helper'
 
-class Mongoid::Alize::SpecToCallback < Mongoid::Alize::ToCallback
-  def define_callback
-    klass.class_eval <<-CALLBACK
-      def _denormalize_to_head
-      end
-    CALLBACK
-  end
-
-  def define_destroy_callback
-    klass.class_eval <<-CALLBACK
-      def _denormalize_destroy_to_head
-      end
-    CALLBACK
-  end
-end
-
 describe Mongoid::Alize::ToCallback do
   def klass
-    Mongoid::Alize::SpecToCallback
+    Mongoid::Alize::ToCallback
   end
 
   def args
-    [Person, :head, [:name, :location, :created_at]]
+    [Person, :head, [:name]]
   end
 
   def new_callback
     klass.new(*args)
   end
 
+  def define_and_create(callback_name=:define_callback)
+    @callback = new_callback
+    @callback.send(:define_fields)
+    create_models
+    @callback.send(callback_name)
+  end
+
   before do
     @callback = new_callback
   end
 
+  describe "names" do
+    it "should assign a destroy callback name" do
+      @callback.destroy_callback_name.should == "_denormalize_destroy_to_head"
+    end
+
+    it "should assign an aliased destroy callback name" do
+      @callback.aliased_destroy_callback_name.should == "denormalize_destroy_to_head"
+    end
+
+    it "should assign a prefixed name from the inverse if present" do
+      @callback.inverse_klass.should == Head
+      @callback.inverse_relation.should == :person
+      @callback.prefixed_name.should == ":person_fields"
+    end
+
+    it "should compute the name on the fly if the inverse is not present" do
+      @callback = klass.new(Head, :nearest, [:name])
+      @callback.inverse_klass.should be_nil
+      @callback.inverse_relation.should be_nil
+      @callback.prefixed_name.should =~ /relation/
+    end
+  end
+
+  describe "#define_fields" do
+    it "should define the fields method" do
+      mock(@callback).define_fields_method
+      @callback.send(:define_fields)
+    end
+  end
+
   describe "#set_callback" do
     it "should set a callback on the klass" do
       mock(@callback.klass).set_callback(:save, :after, "denormalize_to_head")
@@ -62,6 +83,7 @@ describe Mongoid::Alize::ToCallback do
   describe "#alias_destroy_callback" do
     it "should alias the destroy callback on the klass" do
       mock(@callback.klass).alias_method("denormalize_destroy_to_head", "_denormalize_destroy_to_head")
+      mock(@callback.klass).public("denormalize_destroy_to_head")
       @callback.send(:alias_destroy_callback)
     end
 
@@ -71,4 +93,51 @@ describe Mongoid::Alize::ToCallback do
       @callback.send(:alias_destroy_callback)
     end
   end
+
+  describe "not modifying frozen hashes" do
+    def create_models
+      @person = Person.create!(:name => @name = "George")
+      @head = Head.create(:person => @person)
+    end
+
+    def person_fields
+      { :name => @name }
+    end
+
+    before do
+      Head.class_eval do
+        field :person_fields, :type => Hash, :default => {}
+      end
+      define_and_create(:define_destroy_callback)
+    end
+
+    describe "#define_callback" do
+      def run_callback
+        @person.send(:_denormalize_to_head)
+      end
+
+      before do
+        define_and_create(:define_callback)
+      end
+
+      it "should not modify object frozen for deletion" do
+        @head.destroy
+        run_callback
+        @head.person_fields.should == {}
+      end
+    end
+
+    describe "#define_destroy_callback" do
+      def run_callback
+        @person.send(:_denormalize_destroy_to_head)
+      end
+
+      it "should not modify object frozen for deletion" do
+        @head.person_fields = person_fields
+        @head.destroy
+        run_callback
+        @head.person_fields.should == person_fields
+      end
+    end
+  end
 end

data/spec/mongoid_alize_spec.rb

@@ -24,8 +24,10 @@ describe Mongoid::Alize do
       end
 
       def assert_head
-        @head.person_name.should == @name
-        @head.person_location.should == "Paris"
+        @head.person_fields.should == {
+          "name" => @name,
+          "location" => "Paris"
+        }
       end
 
       it "should pull data from person on create" do
@@ -42,9 +44,9 @@ describe Mongoid::Alize do
 
       it "should not pull data from an unchanged person on save" do
         @head.save!
-        @head.person_name = "Cowboy"
+        @head.person_fields["name"] = "Cowboy"
         @head.save!
-        @head.person_name.should == "Cowboy"
+        @head.person_fields["name"].should == "Cowboy"
       end
 
       it "should push data to head" do
@@ -53,10 +55,9 @@ describe Mongoid::Alize do
       end
 
       it "should nillify person fields in head when person is destroyed" do
-        @head.update_attributes!(:person_name => "Old Gregg")
+        @head.update_attributes!(:person_fields => { "name" => "Old Gregg", "location" => "Paris" })
         @person.destroy
-        @head.person_name.should be_nil
-        @head.person_location.should be_nil
+        @head.person_fields.should be_nil
       end
     end
 
@@ -67,7 +68,7 @@ describe Mongoid::Alize do
       end
 
       def assert_person
-        @person.head_size.should == @size
+        @person.head_fields.should == { "size" => @size }
       end
 
       it "should pull data from head on create" do
@@ -88,9 +89,9 @@ describe Mongoid::Alize do
       end
 
       it "should nillify head fields in person when head is destroyed" do
-        @person.update_attributes!(:head_size => "1000 balloons")
+        @person.update_attributes!(:head_fields => { "size" => "1000 balloons"})
         @head.destroy
-        @person.head_size.should be_nil
+        @person.head_fields.should be_nil
       end
     end
   end
@@ -103,7 +104,7 @@ describe Mongoid::Alize do
       end
 
       def assert_captor
-        @head.captor_name.should == @name
+        @head.captor_fields.should == { "name" => @name, "location" => "Paris" }
       end
 
       it "should pull data from captor on create" do
@@ -124,9 +125,9 @@ describe Mongoid::Alize do
       end
 
       it "should nillify captor fields when person is destroyed" do
-        @head.update_attributes!(:captor_name => "Old Gregg")
+        @head.update_attributes!(:captor => { "name" => "Old Gregg"})
         @person.destroy
-        @head.captor_name.should be_nil
+        @head.captor_fields.should be_nil
       end
     end
 
@@ -216,15 +217,45 @@ describe Mongoid::Alize do
   end
 
   describe "without specifying fields" do
-    before do
-      Head.send(:alize, :person)
-      @head.person = @person
+    describe "for non-polymorphic" do
+      before do
+        @head.person = @person
+      end
+
+      it "should denormalize all non-internal fields" do
+        Head.send(:alize, :person)
+        @head.save!
+        @head.person_fields.should == {
+          "name" => @name,
+          "created_at" => @person.created_at,
+          "seen_by_id" => nil,
+          "want_ids" => []
+        }
+      end
+
+      it "should denormalize all non-internal fields" do
+        Head.send(:alize, :person)
+        @person.save!
+        @head.person_fields.should == {
+          "name" => @name,
+          "created_at" => @person.created_at,
+          "seen_by_id" => nil,
+          "want_ids" => []
+        }
+      end
     end
 
-    it "should denormalize all non-internal fields" do
-      @head.save!
-      @head.person_name.should == @name
-      @head.person_created_at.to_i.should == @now.to_i
+    describe "for polymorphic" do
+      before do
+        @head.person = @person
+      end
+
+      it "should denormalize no default fields for a polymorphic child side" do
+        @head.nearest = @person
+        Head.send(:alize_from, :nearest)
+        @head.save!
+        @head.nearest_fields.should == {}
+      end
     end
   end
 
@@ -249,7 +280,7 @@ describe Mongoid::Alize do
 
     it "should be possible to define a method before alize and call the alize version within it" do
       @head.save!
-      @head.person_name.should == "Overrider"
+      @head.person_fields["name"].should == "Overrider"
     end
   end
 
@@ -269,7 +300,7 @@ describe Mongoid::Alize do
 
     it "should be possible to define a method before alize and call the alize version within it" do
       @person.update_attributes!(:name => @name = "Bill")
-      @head.person_name.should == "Overrider"
+      @head.person_fields["name"].should == "Overrider"
     end
   end
 
@@ -287,16 +318,204 @@ describe Mongoid::Alize do
         end
       end
 
-      @head.person_name = "Misty"
+      @head.person_fields["name"] = "Misty"
       @head.save!
-      @head.person_name.should == @name
+      @head.person_fields["name"] = @name
     end
 
     it "should allow using the force_denormalization attribute to force denormalization" do
-      @head.person_name = "Misty"
+      @head.person_fields["name"] = "Misty"
       @head.force_denormalization = true
       @head.save!
-      @head.person_name.should == @name
+      @head.person_fields["name"] = @name
+    end
+  end
+
+  describe "using a proc to define fields" do
+    before do
+      Head.send(:alize, :person, :fields => lambda { |inverse|
+        self.alize_fields(inverse) })
+      @head.person = @person
+    end
+
+    def assert_head
+      @head.person_fields.should == {
+        "name" => @name,
+        "location" => "Paris"
+      }
+    end
+
+    it "should work the same way as it does with fields specified" do
+      @head.save!
+      assert_head
+    end
+  end
+
+  describe "using a proc to define fields for a one-to-one polymorphic association from the belongs to side" do
+    before do
+      Head.send(:alize, :nearest, :fields => lambda { |inverse|
+        self.alize_fields(inverse) })
+      @head.nearest = @person
+    end
+
+    def assert_head
+      @head.nearest_fields.should == {
+        "name" => @name,
+        "location" => "Paris"
+      }
+    end
+
+    it "should work the same way as it does with fields specified" do
+      @head.save!
+      assert_head
+    end
+  end
+
+  describe "using a proc to define fields for a one-to-one polymorphic association from the has one side" do
+    before do
+      Person.send(:alize, :nearest_head, :fields => lambda { |inverse|
+        self.alize_fields(inverse) })
+      @person.nearest_head = @head
+    end
+
+    def assert_person
+      @person.nearest_head_fields.should == {
+        "size" => @size
+      }
+    end
+
+    it "should work the same way as it does with fields specified" do
+      @person.save!
+      assert_person
+    end
+  end
+
+  describe "using a proc to define fields for a has many polymorphic association from the :as side" do
+    before do
+      Head.send(:alize, :below_people, :fields => lambda { |inverse|
+        self.alize_fields(inverse) })
+      @head.below_people = [@person]
+    end
+
+    def assert_head
+      @head.below_people_fields.should == [{
+        "_id" => @person.id,
+        "name" => @name,
+        "location" => "Paris"
+      }]
+    end
+
+    it "should work the same way as it does with fields specified" do
+      @head.save!
+      assert_head
+    end
+  end
+
+  describe "using a proc to define fields for a has many polymorphic association from the belongs_to side" do
+    before do
+      Person.send(:alize, :above, :fields => lambda { |inverse|
+        self.alize_fields(inverse) })
+      @person.above = @head
+    end
+
+    def assert_person
+      @person.above_fields.should == {
+        "size" => @size,
+      }
+    end
+
+    it "should work the same way as it does with fields specified" do
+      @person.save!
+      assert_person
+    end
+  end
+
+  describe "the push on the child side of a one-to-one polymorphic" do
+    before do
+      fields = { :fields => lambda { |person| [:name, :location] } }
+      Head.send(:alize, :nearest, fields)
+      Person.send(:alize_to, :nearest_head, fields)
+      @head.nearest = @person
+    end
+
+    def assert_head
+      @head.nearest_fields.should == {
+        "name" => @name,
+        "location" => "Paris"
+      }
+    end
+
+    it "should push the new fields" do
+      @head.save!
+      assert_head
+      @person.update_attributes!(:name => @name = "George")
+      assert_head
+    end
+  end
+
+  describe "the push on the child side of a one-to-many polymorphic" do
+    before do
+      fields = { :fields => lambda { |head| [:size] } }
+      Person.send(:alize, :above, fields)
+      Head.send(:alize_to, :below_people, fields)
+      @person.above = @head
+    end
+
+    def assert_person
+      @person.above_fields.should == {
+        "size" => @size
+      }
+    end
+
+    it "should push the new fields" do
+      @person.save!
+      assert_person
+      @head.update_attributes!(:size => @size = 5)
+      assert_person
+    end
+  end
+
+  describe "the push on the parent side of a one-to-one polymorphic" do
+    before do
+      fields = { :fields => lambda { |inverse| [:size] } }
+      Person.send(:alize, :nearest_head, fields)
+      @person.nearest_head = @head
+      @person.save!
+    end
+
+    def assert_person
+      @person.nearest_head_fields.should == {
+        "size" => @size
+      }
+    end
+
+    it "should push the new fields" do
+      assert_person
+      @head.update_attributes!(:size => @size = 5)
+      assert_person
+    end
+  end
+
+  describe "the push on the parent side of a one-to-many polymorphic" do
+    before do
+      fields = { :fields => lambda { |inverse| [:name, :location] } }
+      Head.send(:alize, :below_people, fields)
+      @head.below_people = [@person]
+      @head.save!
+    end
+
+    def assert_head
+      @head.below_people_fields.should == [{
+        "_id" => @person.id,
+        "name" => @name,
+        "location" => "Paris"
+      }]
+    end
+
+    it "should push the new fields" do
+      assert_head
+      @person.update_attributes!(:name => @name = "George")
+      assert_head
     end
   end
 end