mongoid_alize 0.1.0

data/spec/app/models/person.rb

@@ -0,0 +1,21 @@
+class Person
+  include Mongoid::Document
+  include Mongoid::Alize
+
+  field :name, type: String
+  field :created_at, type: Time
+
+  # the attached head
+  has_one :head
+
+  # the heads taken from others
+  has_many :heads, :class_name => "Head", :inverse_of => :captor
+
+  # the heads wanted from others
+  has_and_belongs_to_many :wants, :class_name => "Head", :inverse_of => :wanted_by
+
+  # the only head that is watching
+  belongs_to :seen_by, :class_name => "Head", :inverse_of => :sees
+
+end
+

data/spec/helpers/macros_helper.rb

@@ -0,0 +1,45 @@
+module MacrosHelper
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def fns
+      Mongoid::Alize::Callbacks::From
+    end
+
+    def tns
+      Mongoid::Alize::Callbacks::To
+    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
+
+        stub(tns).new { obj_stub }
+        stub(obj_stub).attach
+        stub(inverse_klass)
+
+        mock(fns).new(klass, relation, fields) { obj_mock }
+        mock(obj_mock).attach
+        klass.send(:alize, relation, *fields)
+      end
+
+      it "should use #{tns} to push" do
+        obj_stub = Object.new
+        obj_mock = Object.new
+
+        stub(fns).new { obj_stub }
+        stub(obj_stub).attach
+        stub(klass).set_callback
+
+        mock(tns).new(inverse_klass, inverse_relation, fields) { obj_mock }
+        mock(obj_mock).attach
+        klass.send(:alize, relation, *fields)
+      end
+    end
+  end
+end

data/spec/mongoid/alize/callback_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Mongoid::Alize::Callback do
+  def klass
+    Mongoid::Alize::Callback
+  end
+
+  def args
+    [Head, :person, [:name, :created_at]]
+  end
+
+  def new_unit
+    klass.new(*args)
+  end
+
+  describe "initialize" do
+    it "should assign class attributes" do
+      unit = new_unit
+      unit.klass.should == Head
+      unit.relation.should == :person
+      unit.inverse_klass = Person
+      unit.inverse_relation = :head
+      unit.fields.should == [:name, :created_at]
+    end
+  end
+end
+

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Mongoid::Alize::Callbacks::From::Many do
+  def klass
+    Mongoid::Alize::Callbacks::From::Many
+  end
+
+  def args
+    [Head, :wanted_by, [:name, :created_at]]
+  end
+
+  def new_unit
+    klass.new(*args)
+  end
+
+  describe "#define_fields" do
+    it "should define an Array called {relation}_fields" do
+      unit = new_unit
+      unit.send(:define_fields)
+      Head.fields["wanted_by_fields"].type.should == Array
+    end
+  end
+
+  describe "the defined callback" do
+    def run_callback
+      @head.send(callback_name)
+    end
+
+    def callback_name
+      "denormalize_from_wanted_by"
+    end
+
+    before do
+      @head = Head.create(
+        :wanted_by => [@person = Person.create(:name => "Bob",
+                                        :created_at => @now = Time.now)])
+
+      @unit = new_unit
+      @unit.send(:define_fields)
+      @unit.send(:define_callback)
+    end
+
+    it "should pull the fields from the relation" do
+      @head.wanted_by_fields.should be_nil
+      run_callback
+      @head.wanted_by_fields.should == [{
+        "_id" => @person.id,
+        "name"=> "Bob",
+        "created_at"=> @now.to_s(:utc)
+      }]
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Mongoid::Alize::Callbacks::From::One do
+  def klass
+    Mongoid::Alize::Callbacks::From::One
+  end
+
+  def args
+    [Head, :person, [:name, :created_at]]
+  end
+
+  def new_unit
+    klass.new(*args)
+  end
+
+  describe "#define_fields" do
+    it "should add properly typed, prefixed fields from the relation" do
+      unit = new_unit
+      unit.send(:define_fields)
+      Head.fields["person_name"].type.should == String
+      Head.fields["person_created_at"].type.should == Time
+    end
+  end
+
+  describe "the defined callback" do
+    def run_callback
+      @head.send(callback_name)
+    end
+
+    def callback_name
+      "denormalize_from_person"
+    end
+
+    before do
+      @head = Head.create(
+        :person => @person = Person.create(:name => @name = "Bob",
+                                           :created_at => @now = Time.now))
+      @unit = new_unit
+      @unit.send(:define_fields)
+      @unit.send(:define_callback)
+    end
+
+    it "should set pull fields from the relation" do
+      @head.person_name.should be_nil
+      @head.person_created_at.should be_nil
+      run_callback
+      @head.person_name.should == @name
+      @head.person_created_at.to_i.should == @now.to_i
+    end
+
+    it "should assign nil values if the relation is nil" do
+      @head.person_name = "not nil"
+      @head.person_created_at = Time.now
+      @head.person = nil
+      run_callback
+      @head.person_name.should be_nil
+      @head.person_created_at.should be_nil
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe Mongoid::Alize::Callbacks::To::ManyFromMany do
+  def klass
+    Mongoid::Alize::Callbacks::To::ManyFromMany
+  end
+
+  def args
+    [Person, :wants, [:name, :created_at]]
+  end
+
+  def new_unit
+    klass.new(*args)
+  end
+
+  def wanted_by_fields
+    { "_id" => @person.id,
+        "name"=> "Bob",
+        "created_at"=> @now.to_s(:utc) }
+  end
+
+  def other_wanted_by
+    { "_id" => "SomeObjectId" }
+  end
+
+  before do
+    Head.class_eval do
+      field :wanted_by_fields, type: Array
+    end
+
+    @head = Head.create(
+      :wanted_by => [@person = Person.create(:name => "Bob",
+                                      :created_at => @now = Time.now)])
+    @person.wants = [@head]
+
+    @unit = new_unit
+  end
+
+  describe "#define_callback" do
+    before do
+      @unit.send(:define_callback)
+    end
+
+    def run_callback
+      @person.send(callback_name)
+    end
+
+    def callback_name
+      "denormalize_to_wants"
+    end
+
+    it "should push the fields to the relation" do
+      @head.wanted_by_fields.should be_nil
+      run_callback
+      @head.wanted_by_fields.should == [wanted_by_fields]
+    end
+
+    it "should pull first any existing array entries matching the _id" do
+      @head.wanted_by_fields = [other_wanted_by]
+      @head.save!
+
+      run_callback
+      run_callback
+
+      # to make sure persisted in both DB and updated in memory
+      @head.wanted_by_fields.should == [other_wanted_by, wanted_by_fields]
+      @head.reload
+      @head.wanted_by_fields.should == [other_wanted_by, wanted_by_fields]
+    end
+  end
+
+  describe "#define_destroy_callback" do
+    before do
+      @unit.send(:define_destroy_callback)
+    end
+
+    def run_destroy_callback
+      @person.send(destroy_callback_name)
+    end
+
+    def destroy_callback_name
+      "denormalize_destroy_to_wants"
+    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!
+
+      run_destroy_callback
+
+      # to make sure persisted in both DB and updated in memory
+      @head.wanted_by_fields.should == [other_wanted_by]
+      @head.reload
+      @head.wanted_by_fields.should == [other_wanted_by]
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Mongoid::Alize::Callbacks::To::ManyFromOne do
+  def klass
+    Mongoid::Alize::Callbacks::To::ManyFromOne
+  end
+
+  def args
+    [Person, :seen_by, [:name, :created_at]]
+  end
+
+  def new_unit
+    klass.new(*args)
+  end
+
+  def sees_fields
+    { "_id" => @person.id,
+      "name"=> "Bob",
+      "created_at"=> @now.to_s(:utc) }
+  end
+
+  def other_see
+    { "_id" => "SomeObjectId" }
+  end
+
+  before do
+    Head.class_eval do
+      field :sees_fields, :type => Array
+    end
+
+    @head = Head.create(
+      :sees => [@person = Person.create(:name => "Bob",
+                                      :created_at => @now = Time.now)])
+    @person.seen_by = @head
+    @unit = new_unit
+  end
+
+  describe "#define_callback" do
+    before do
+      @unit.send(:define_callback)
+    end
+
+    def run_callback
+      @person.send(callback_name)
+    end
+
+    def callback_name
+      "denormalize_to_seen_by"
+    end
+
+    it "should push the fields to the relation" do
+      @head.sees_fields.should be_nil
+      run_callback
+      @head.sees_fields.should == [sees_fields]
+    end
+
+    it "should pull first any existing array entries matching the _id" do
+      @head.sees_fields = [other_see]
+      @head.save!
+
+      run_callback
+      run_callback
+
+      # to make sure persisted in both DB and updated in memory
+      @head.sees_fields.should == [other_see, sees_fields]
+      @head.reload
+      @head.sees_fields.should == [other_see, sees_fields]
+    end
+
+    it "should do nothing if the inverse is nil" do
+      @person.seen_by = nil
+      run_callback
+    end
+  end
+
+  describe "#define_destroy_callback" do
+    before do
+      @unit.send(:define_destroy_callback)
+    end
+
+    def run_destroy_callback
+      @person.send(destroy_callback_name)
+    end
+
+    def destroy_callback_name
+      "denormalize_destroy_to_seen_by"
+    end
+
+    it "should pull first any existing array entries matching the _id" do
+      @head.sees_fields = [sees_fields, other_see]
+      @head.save!
+
+      run_destroy_callback
+
+      # to make sure persisted in both DB and updated in memory
+      @head.sees_fields.should == [other_see]
+      @head.reload
+      @head.sees_fields.should == [other_see]
+    end
+
+    it "should do nothing if the inverse is nil" do
+      @person.seen_by = nil
+      run_destroy_callback
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Mongoid::Alize::Callbacks::To::OneFromMany do
+  def klass
+    Mongoid::Alize::Callbacks::To::OneFromMany
+  end
+
+  def args
+    [Person, :heads, [:name, :created_at]]
+  end
+
+  def new_unit
+    klass.new(*args)
+  end
+
+  before do
+    Head.class_eval do
+      field :captor_name, :type => String
+      field :captor_created_at, :type => Time
+    end
+
+    @head = Head.create(
+      :captor => @person = Person.create(:name => "Bob",
+                                         :created_at => @now = Time.now))
+    @person.heads = [@head]
+
+    @unit = new_unit
+  end
+
+  describe "#define_callback" do
+    before do
+      @unit.send(:define_callback)
+    end
+
+    def run_callback
+      @person.send(callback_name)
+    end
+
+    def callback_name
+      "denormalize_to_heads"
+    end
+
+    it "should push the fields to the relation" do
+      @head.captor_name.should be_nil
+      @head.captor_created_at.should be_nil
+      run_callback
+      @head.captor_name.should == "Bob"
+      @head.captor_created_at.to_i.should == @now.to_i
+    end
+  end
+
+  describe "#define_destroy_callback" do
+    def run_destroy_callback
+      @person.send(destroy_callback_name)
+    end
+
+    def destroy_callback_name
+      "denormalize_destroy_to_heads"
+    end
+
+    before do
+      @unit.send(:define_destroy_callback)
+    end
+
+    it "should remove the fields from the relation" do
+      @head.captor_name.should be_nil
+      @head.captor_created_at.should be_nil
+      run_destroy_callback
+      @head.captor_name.should be_nil
+      @head.captor_created_at.should be_nil
+    end
+  end
+end