mongoid_alize 0.2.0 → 0.3.1

data/lib/mongoid_alize.rb

@@ -1,23 +1,18 @@
 require 'mongoid/alize/errors/alize_error'
 require 'mongoid/alize/errors/invalid_field'
 require 'mongoid/alize/errors/already_defined_field'
+require 'mongoid/alize/errors/invalid_configuration'
 
 require 'mongoid/alize/callback'
 
 require 'mongoid/alize/from_callback.rb'
 require 'mongoid/alize/to_callback.rb'
-require 'mongoid/alize/to_one_callback.rb'
-require 'mongoid/alize/to_many_callback.rb'
 
 require 'mongoid/alize/callbacks/from/one.rb'
 require 'mongoid/alize/callbacks/from/many.rb'
 
-require 'mongoid/alize/callbacks/to/one_from_one.rb'
-require 'mongoid/alize/callbacks/to/one_from_many.rb'
-require 'mongoid/alize/callbacks/to/many_from_one.rb'
-require 'mongoid/alize/callbacks/to/many_from_many.rb'
-
 require 'mongoid/alize/macros'
+require 'mongoid/alize/instance_helpers'
 
 I18n.load_path << File.join(File.dirname(__FILE__), "..", "config", "locales", "en.yml")
 
@@ -27,6 +22,7 @@ module Mongoid
 
     included do
       extend Mongoid::Alize::Macros
+      include Mongoid::Alize::InstanceHelpers
     end
   end
 end

data/spec/app/models/head.rb

@@ -8,7 +8,7 @@ class Head
   # to whom it's attached
   belongs_to :person
 
-  # in who's possession it is
+  # in whose possession it is
   belongs_to :captor, :class_name => "Person", :inverse_of => :heads
 
   # who'd otherwise like to possess it
@@ -20,7 +20,23 @@ class Head
   # a relation with no inverse
   has_many :admirer, :class_name => "Person", :inverse_of => nil
 
+  # a polymorphic one-to-one relation
+  belongs_to :nearest, :polymorphic => true
+
+  # a polymorphic one-to-many relation
+  has_many :below_people, :class_name => "Person", :as => :above
+
   def density
     "low"
   end
+
+  # example of one way to handling attribute selection
+  # for polymorphic associations or generally using the proc fields option
+  def alize_fields(inverse)
+    if inverse.is_a?(Person)
+      [:name, :location]
+    else
+      [:id]
+    end
+  end
 end

data/spec/app/models/mock_object.rb

@@ -0,0 +1,6 @@
+# explicit mock object class due to this issue - https://github.com/btakita/rr/issues/44
+class MockObject
+  def to_ary
+    nil
+  end
+end

data/spec/app/models/person.rb

@@ -17,8 +17,24 @@ class Person
   # the only head that is watching
   belongs_to :seen_by, :class_name => "Head", :inverse_of => :sees
 
+  # a polymorphic one-to-one relation
+  has_one :nearest_head, :class_name => "Head", :as => :nearest
+
+  # a polymorphic one-to-many relation
+  belongs_to :above, :polymorphic => true
+
   def location
     "Paris"
   end
+
+  # example of one way to handling attribute selection
+  # for polymorphic associations or generally using the proc fields option
+  def alize_fields(inverse)
+    if inverse.is_a?(Head)
+      [:size]
+    else
+      [:id]
+    end
+  end
 end
 

data/spec/helpers/macros_helper.rb

@@ -9,15 +9,15 @@ module MacrosHelper
     end
 
     def tns
-      Mongoid::Alize::Callbacks::To
+      Mongoid::Alize::ToCallback
     end
 
     def it_should_set_callbacks(klass, inverse_klass, relation, inverse_relation, fns, tns)
       fields = [:fake]
 
       it "should use #{fns} to pull" do
-        obj_mock = Object.new
-        obj_stub = Object.new
+        obj_mock = MockObject.new
+        obj_stub = MockObject.new
 
         stub(tns).new { obj_stub }
         stub(obj_stub).attach
@@ -25,12 +25,14 @@ module MacrosHelper
 
         mock(fns).new(klass, relation, fields) { obj_mock }
         mock(obj_mock).attach
-        klass.send(:alize, relation, *fields)
+        klass.send(:alize_from, relation, *fields)
+
+        klass.alize_from_callbacks.should == [obj_mock]
       end
 
       it "should use #{tns} to push" do
-        obj_stub = Object.new
-        obj_mock = Object.new
+        obj_stub = MockObject.new
+        obj_mock = MockObject.new
 
         stub(fns).new { obj_stub }
         stub(obj_stub).attach
@@ -38,7 +40,9 @@ module MacrosHelper
 
         mock(tns).new(inverse_klass, inverse_relation, fields) { obj_mock }
         mock(obj_mock).attach
-        klass.send(:alize, relation, *fields)
+        inverse_klass.send(:alize_to, inverse_relation, *fields)
+
+        inverse_klass.alize_to_callbacks.should == [obj_mock]
       end
     end
   end

data/spec/mongoid/alize/callback_spec.rb

@@ -33,24 +33,32 @@ describe Mongoid::Alize::Callback do
       callback.relation.should == :person
       callback.inverse_klass = Person
       callback.inverse_relation = :head
+      callback.inverse_metadata.should == Person.relations["head"]
       callback.fields.should == [:name, :created_at]
     end
 
-    it "should add force_denormalization attribute to klass and inverse klass" do
-      callback = new_callback
-      Head.new.force_denormalization = true
-      Person.new.force_denormalization = true
+    it "should not set inverses for the child in a polymorphic association" do
+      callback = klass.new(Head, :nearest, [:size])
+      callback.inverse_klass.should be_nil
+      callback.inverse_relation.should be_nil
+    end
+
+    it "should set inverses for the parent in a polymorphic association" do
+      callback = klass.new(Person, :nearest_head, [:size])
+      callback.inverse_klass.should == Head
+      callback.inverse_relation.should == :nearest
     end
   end
 
-  describe "with callback " do
+  describe "with callback" do
     before do
       @callback = new_callback
     end
 
     describe "#alias_callback" do
-      it "should alias the callback on the klass" do
+      it "should alias the callback on the klass and make it public" do
         mock(@callback.klass).alias_method("denormalize_spec_person", "_denormalize_spec_person")
+        mock(@callback.klass).public("denormalize_spec_person")
         @callback.send(:alias_callback)
       end
 
@@ -61,5 +69,53 @@ describe Mongoid::Alize::Callback do
       end
     end
   end
+
+  describe "name helpers" do
+    before do
+      @callback = new_callback
+    end
+
+    it "should have a callback name" do
+      @callback.callback_name.should == "_denormalize_spec_person"
+    end
+
+    it "should have aliased callback name" do
+      @callback.aliased_callback_name.should == "denormalize_spec_person"
+    end
+
+    it "should add _fields to the callback name" do
+      @callback.fields_method_name.should == "_denormalize_spec_person_fields"
+    end
+  end
+
+  describe "define fields method" do
+    def define_fields_method
+      @callback.send(:define_fields_method)
+    end
+
+    describe "when fields is an array" do
+      before do
+        @callback = new_callback
+      end
+
+      it "should return the fields w/ to_s applied" do
+        define_fields_method
+        @head = Head.new
+        @head.send("_denormalize_spec_person_fields", nil).should == ["name", "created_at"]
+      end
+    end
+
+    describe "when fields is a proc" do
+      before do
+        @callback = klass.new(Head, :person, lambda { |inverse| [:name, :created_at] })
+      end
+
+      it "should return the fields w/ to_s applied" do
+        define_fields_method
+        @head = Head.new
+        @head.send("_denormalize_spec_person_fields", Person.new).should == ["name", "created_at"]
+      end
+    end
+  end
 end
 

data/spec/mongoid/alize/callbacks/from/one_spec.rb

@@ -14,39 +14,29 @@ describe Mongoid::Alize::Callbacks::From::One do
   end
 
   describe "#define_fields" do
-    it "should add properly typed, prefixed fields from the relation" do
-      callback = klass.new(Head, :person, [:name, :created_at])
-      callback.send(:define_fields)
-      Head.fields["person_name"].type.should == String
-      Head.fields["person_created_at"].type.should == Time
-    end
-
-    it "should define as a string field that's not defined" do
-      callback = klass.new(Head, :person, [:location])
-      callback.send(:define_fields)
-      Head.fields["person_location"].type.should == String
-    end
-
-    it "should not add the field if the field already exists" do
-      Head.class_eval do
-        field :person_name
+    describe "with an array of fields" do
+      it "should add a field generated from %{relation}_fields" do
+        callback = new_callback
+        callback.send(:define_fields)
+        Head.fields["person_fields"].type.should == Hash
       end
-      callback = klass.new(Head, :person, [:name])
-      dont_allow(Head).field
-      callback.send(:define_fields)
-    end
 
-    it "should not add the field if it already exists b/c of another relation" do
-      callback = klass.new(Head, :person, [:id])
-      dont_allow(Head).field
-      callback.send(:define_fields)
-    end
+      it "should default the field to nil" do
+        callback = new_callback
+        callback.send(:define_fields)
+        Head.new.person_fields.should be_nil
+      end
 
-    it "should allow the id and type of the inverse to be denormalized without an extra _" do
-      callback = klass.new(Person, :head, [:id, :type])
-      callback.send(:define_fields)
-      Person.fields["head_id"].type.should == BSON::ObjectId
-      Person.fields["head_type"].type.should == String
+      it "should raise an already defined field error if the field already exists" do
+        Head.class_eval do
+          field :person_fields
+        end
+        callback = new_callback
+        expect {
+          callback.send(:define_fields)
+        }.to raise_error(Mongoid::Alize::Errors::AlreadyDefinedField,
+                         "person_fields is already defined on the Head model.")
+      end
     end
   end
 
@@ -55,37 +45,43 @@ describe Mongoid::Alize::Callbacks::From::One do
       @head.send(:_denormalize_from_person, force)
     end
 
-    before do
+    def person_fields
+      { "name"=> "Bob",
+        "location" => "Paris",
+        "created_at"=> @now.to_s(:utc) }
+    end
+
+    def create_models
       @head = Head.create
       @person = Person.create(:name => @name = "Bob",
                               :created_at => @now = Time.now)
+    end
 
+    before do
       @callback = new_callback
       @callback.send(:define_fields)
+      create_models
       @callback.send(:define_callback)
-
-      @head.relations["person"].should be_stores_foreign_key
     end
 
     it "should set fields from a changed relation" do
       @head.person = @person
       @head.should be_person_id_changed
       run_callback
-      @head.person_name.should == @name
-      @head.person_created_at.to_i.should == @now.to_i
-      @head.person_location.should == "Paris"
+      @head.person_fields.should == person_fields
     end
 
-    it "should assign nil values if the changed relation is nil" do
+    it "should set no fields from a nil relation" do
       @head.person = @person
       @head.save!
       @head.person = nil
       @head.should be_person_id_changed
       run_callback
-      @head.person_name.should be_nil
+      @head.person_fields.should == nil
     end
 
     it "should not run if the relation has not changed" do
+      @head.relations["person"].should be_stores_foreign_key
       @head.should_not be_person_id_changed
       dont_allow(@head).person
       run_callback
@@ -111,20 +107,22 @@ describe Mongoid::Alize::Callbacks::From::One do
     end
 
     before do
+      @callback = klass.new(Person, :head, [:size])
+      @callback.send(:define_fields)
+
       @person = Person.create
       @head = Head.create(:size => 5)
 
-      @callback = klass.new(Person, :head, [:size])
-      @callback.send(:define_fields)
       @callback.send(:define_callback)
-
       @person.relations["head"].should_not be_stores_foreign_key
     end
 
     it "should set values from a changed relation" do
       @person.head = @head
       run_callback
-      @person.head_size.should == 5
+      @person.head_fields.should == {
+        "size" => 5
+      }
     end
 
     it "should set values from a a nil relation" do
@@ -132,7 +130,7 @@ describe Mongoid::Alize::Callbacks::From::One do
       @person.save!
       @person.head = nil
       run_callback
-      @person.head_size.should be_nil
+      @person.head_fields.should be_nil
     end
 
     it "should run even if the relation has not changed" do

data/spec/mongoid/alize/callbacks/to/many_from_many_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Mongoid::Alize::Callbacks::To::ManyFromMany do
+describe Mongoid::Alize::ToCallback do
   def klass
-    Mongoid::Alize::Callbacks::To::ManyFromMany
+    Mongoid::Alize::ToCallback
   end
 
   def args
@@ -24,30 +24,33 @@ describe Mongoid::Alize::Callbacks::To::ManyFromMany do
     { "_id" => "SomeObjectId" }
   end
 
-  before do
-    Head.class_eval do
-      field :wanted_by_fields, type: Array
-    end
-
+  def create_models
     @head = Head.create(
       :wanted_by => [@person = Person.create(:name => "Bob",
                                       :created_at => @now = Time.now)])
     @person.wants = [@head]
-
-    @callback = new_callback
   end
 
-  describe "#define_callback" do
-    before do
-      @callback.send(:define_callback)
+  before do
+    Head.class_eval do
+      field :wanted_by_fields, type: Array, :default => []
     end
+  end
 
+  describe "#define_callback" do
     def run_callback
       @person.send(:_denormalize_to_wants)
     end
 
+    before do
+      @callback = new_callback
+      @callback.send(:define_fields)
+      create_models
+      @callback.send(:define_callback)
+    end
+
     it "should push the fields to the relation" do
-      @head.wanted_by_fields.should be_nil
+      @head.wanted_by_fields.should == []
       run_callback
       @head.wanted_by_fields.should == [wanted_by_fields]
     end
@@ -67,14 +70,17 @@ describe Mongoid::Alize::Callbacks::To::ManyFromMany do
   end
 
   describe "#define_destroy_callback" do
-    before do
-      @callback.send(:define_destroy_callback)
-    end
-
     def run_destroy_callback
       @person.send(:_denormalize_destroy_to_wants)
     end
 
+    before do
+      @callback = new_callback
+      @callback.send(:define_fields)
+      create_models
+      @callback.send(:define_destroy_callback)
+    end
+
     it "should pull first any existing array entries matching the _id" do
       @head.wanted_by_fields = [wanted_by_fields, other_wanted_by]
       @head.save!