motion-yapper 0.0.1

data/lib/yapper/timestamps.rb

@@ -0,0 +1,16 @@
+module Yapper::Timestamps
+  extend MotionSupport::Concern
+
+  included do
+    field :updated_at, :type => Time
+    field :created_at, :type => Time
+
+    before_save :set_timestamps
+  end
+
+  def set_timestamps
+    now = Time.now
+    self.created_at = now if created_at.nil?
+    self.updated_at = now
+  end
+end

data/lib/yapper/version.rb

@@ -0,0 +1,3 @@
+module Yapper
+  VERSION = '0.0.1'
+end

data/lib/yapper/yapper.rb

@@ -0,0 +1,2 @@
+module Yapper
+end

data/spec/helpers/time_helper.rb

@@ -0,0 +1,3 @@
+def same_time_as(time)
+  lambda { |obj| time.is_a?(Time) && obj.is_a?(Time) && (time - obj) < 1.0 }
+end

data/spec/integration/all_spec.rb

@@ -0,0 +1,40 @@
+describe '#all' do
+  before do
+    class SelectionDocument
+      include Yapper::Document
+
+      field :field1
+      field :field2
+    end
+    class AnotherSelectionDocument
+      include Yapper::Document
+
+      field :field1
+      field :field2
+    end
+  end
+  before { Yapper::DB.instance.purge }
+  after { Object.send(:remove_const, 'SelectionDocument') }
+  after { Object.send(:remove_const, 'AnotherSelectionDocument') }
+
+  describe 'with no documents created' do
+    it 'returns []' do
+      SelectionDocument.all.should == []
+    end
+  end
+
+  describe 'with a few documents created with string fields' do
+    before do
+      @doc = SelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_value')
+      SelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_value')
+      SelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_other_value')
+      SelectionDocument.create(:field1 => 'field1_other_value', :field2 => 'field2_other_value')
+      AnotherSelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_value')
+    end
+
+    it 'returns all documents' do
+      SelectionDocument.all.count.should == 4
+      SelectionDocument.all.all? { |doc| doc.class.should == SelectionDocument }
+    end
+  end
+end

data/spec/integration/callback_spec.rb

@@ -0,0 +1,87 @@
+describe 'callbacks' do
+  before do
+    class CallbackDocument
+      include Yapper::Document
+
+      field :field_1
+      field :field_2
+
+      before_save :do_before_save
+      before_save :do_another_before_save
+      after_save  :do_after_save
+      after_save  :do_another_after_save
+
+      private
+
+      def do_before_save
+        $before_save_1 = true
+      end
+
+      def do_another_before_save
+        $before_save_2 = true
+      end
+
+      def do_after_save
+        $after_save_1 = true
+      end
+
+      def do_another_after_save
+        $after_save_2 = true
+      end
+    end
+  end
+  before { Yapper::DB.instance.purge }
+  after { Object.send(:remove_const, 'CallbackDocument') }
+
+  describe 'creating documents' do
+    it 'before and after callbacks are fired' do
+      CallbackDocument.create(:field_1 => 'field1',
+                              :field_2 => 'field2')
+
+      $before_save_1.should == true
+      $before_save_2.should == true
+      $after_save_1.should == true
+      $after_save_2.should == true
+    end
+  end
+
+  describe 'updating documents' do
+    before do
+      @doc = CallbackDocument.create(:field_1 => 'field1')
+      $before_save_1 = false
+      $before_save_2 = false
+      $after_save_1 = false
+      $after_save_2 = false
+    end
+
+    it 'before and after callbacks are fired' do
+      @doc.field_1 = 'field1_updated'
+      @doc.save
+
+      $before_save_1.should == true
+      $before_save_2.should == true
+      $after_save_1.should == true
+      $after_save_2.should == true
+    end
+  end
+
+  describe 'on failure' do
+    before do
+      class CallbackDocument
+        after_save  :fail
+
+        def fail
+          raise "fail"
+        end
+      end
+    end
+
+    it 'rollsback the entire update' do
+      lambda {
+        CallbackDocument.create(:field_1 => 'field1')
+      }.should.raise
+
+      CallbackDocument.all.count.should == 0
+    end
+  end
+end

data/spec/integration/db_spec.rb

@@ -0,0 +1,40 @@
+describe 'db' do
+  before do
+    class Document
+      include Yapper::Document
+
+      field :field_1
+      field :field_2
+    end
+
+    class AnotherDocument
+      include Yapper::Document
+
+      field :field_1
+      field :field_2
+    end
+  end
+  before { Yapper::DB.instance.purge }
+  after { Object.send(:remove_const, 'Document') }
+  after { Object.send(:remove_const, 'AnotherDocument') }
+
+  it 'is thread safe' do
+    threads = []
+    threads << Thread.new { 10.times { Document.create(:field_1 => 'field') } }
+    threads << Thread.new { 10.times { AnotherDocument.create(:field_1 => 'field')  } }
+    threads << Thread.new { 10.times { Document.all.each { |d| d.update_attributes(:field_1 => 'bye') } } }
+    threads << Thread.new { 10.times { AnotherDocument.all.each { |d| d.update_attributes(:field_1 => 'bye') } } }
+    threads.each(&:join)
+
+    Document.all.count.should == 10
+    AnotherDocument.all.count.should == 10
+  end
+  
+  it 'can nest transactions' do
+    Yapper::DB.instance.execute do |txn|
+      Document.create(:field_1 => '1')
+      Document.create(:field_1 => '2')
+    end
+    Document.all.count.should == 2
+  end
+end

data/spec/integration/find_spec.rb

@@ -0,0 +1,51 @@
+describe '#find' do
+  before do
+    class SelectionDocument
+      include Yapper::Document
+
+      field :field1
+      field :field2
+    end
+    class AnotherSelectionDocument
+      include Yapper::Document
+
+      field :field1
+      field :field2
+    end
+  end
+  before { Yapper::DB.instance.purge }
+  after { Object.send(:remove_const, 'SelectionDocument') }
+  after { Object.send(:remove_const, 'AnotherSelectionDocument') }
+
+  describe 'with no documents created' do
+    it 'returns nil when looking up a document' do
+      SelectionDocument.find('xxx').should == nil
+    end
+  end
+
+  describe 'with a few documents created with string fields' do
+    before do
+      @doc = SelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_value')
+      SelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_value')
+      SelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_other_value')
+      SelectionDocument.create(:field1 => 'field1_other_value', :field2 => 'field2_other_value')
+      AnotherSelectionDocument.create(:field1 => 'field1_value', :field2 => 'field2_value')
+    end
+
+    it 'can find a document' do
+      SelectionDocument.find(@doc.id).field1.should == 'field1_value'
+    end
+
+    it 'has no changes when selecting a document' do
+      SelectionDocument.find(@doc.id).changes.should == {}
+    end
+
+    it 'returns nil when looking up a non-existant doc' do
+      SelectionDocument.find('xxx').should == nil
+    end
+
+    it 'returns nil when looking up nil' do
+      SelectionDocument.find(nil).should == nil
+    end
+  end
+end

data/spec/integration/persistance_spec.rb

@@ -0,0 +1,118 @@
+describe 'Yapper persisting documents' do
+  before do
+    class Document
+      include Yapper::Document
+
+      field :field_1
+      field :field_2
+    end
+  end
+  before { Yapper::DB.instance.purge }
+  after  { Object.send(:remove_const, 'Document') }
+
+  describe 'creating documents' do
+    it 'supports storing hashes by stringifying keys (to avoid NanoStore bug)' do
+      10.times { Document.create.tap { |doc| doc.update_attributes(:field_1 => { :a => [ { :a => 10 } ] }) } }
+      Document.all.each { |doc| doc.field_1[:b] = 'b'; doc.save }
+
+      Document.all.each { |doc| doc.field_1.should == { 'a' => [ { 'a' => 10 } ], 'b' => 'b' } }
+    end
+
+    it 'supports storing Time' do
+      time = Time.now
+      Document.create(:field_1 => time)
+
+      Document.all.first.field_1.should == time
+    end
+
+    it 'tracks changes' do
+      doc = Document.new
+      doc.field_1 = 'field1'
+      doc.field_2 = 'field2'
+
+      doc.changes.should == { 'id' => doc.id,
+                              'field_1' => 'field1',
+                              'field_2'  => 'field2' }
+    end
+
+    describe "when using #new then #save" do
+      it 'persists the fields' do
+        doc = Document.new
+        doc.field_1 = 'field1'
+        doc.field_2 = 'field2'
+        doc.new_record?.should == true
+        doc.save
+
+        doc = Document.find(doc.id)
+        doc.new_record?.should == false
+        doc.field_1.should == 'field1'
+        doc.field_2.should == 'field2'
+      end
+    end
+
+    describe "when using #create" do
+      it 'persists the fields' do
+        doc = Document.create(:field_1 => 'field1',
+                              :field_2 => 'field2')
+
+        doc = Document.find(doc.id)
+        doc.field_1.should == 'field1'
+        doc.field_2.should == 'field2'
+      end
+    end
+  end
+
+  describe 'updating documents' do
+    before do
+      @doc = Document.create(:field_1 => 'field1')
+    end
+
+    it 'tracks changes' do
+      @doc.field_1 = 'field1_changed'
+
+      @doc.changes.should == { 'field_1' => 'field1_changed' }
+
+      @doc.save
+
+      @doc.changes.should == {}
+      @doc.previous_changes.should == { 'field_1' => 'field1_changed' }
+    end
+
+    it 'saves a false value' do
+      @doc.update_attributes(:field_1 => false)
+
+      @doc.reload.field_1.should == false
+    end
+
+    describe "when updating fields and then #save" do
+      it 'persists the fields' do
+        @doc.field_1 = 'field1_updated'
+        @doc.save
+
+        doc = Document.find(@doc.id)
+        doc.field_1.should == 'field1_updated'
+      end
+    end
+
+    describe "when using #update_attributes" do
+      it 'persists the fields' do
+        @doc.update_attributes(:field_1 => 'field1_updated')
+
+        doc = Document.find(@doc.id)
+        doc.field_1.should == 'field1_updated'
+      end
+    end
+  end
+
+  describe 'destroying documents' do
+    before do
+      @doc = Document.create(:field_1 => 'field1')
+    end
+
+    it 'destroys the document' do
+      @doc.destroy
+
+      Document.find(@doc.id).should == nil
+    end
+  end
+end

data/spec/integration/relation_spec.rb

@@ -0,0 +1,174 @@
+describe 'Yapper document 1:N relationship' do
+  before do
+    class ParentDocument
+      include Yapper::Document
+
+      field :field_1
+
+      has_many :child_documents
+    end
+    class ChildDocument
+      include Yapper::Document
+
+      field :field_1
+      field :field_2
+
+      belongs_to :parent_document
+    end
+  end
+  before { Yapper::DB.instance.purge }
+  after  { ['ParentDocument', 'ChildDocument'].each { |klass| Object.send(:remove_const, klass) } }
+
+  it 'can accept nested attributes' do
+    @parent = ParentDocument.create(:field_1 => 'parent',
+                                    :child_documents => [
+                                      { :field_1 => 'child0' },
+                                      { :field_1 => 'child1' }
+                                    ])
+
+    @parent.field_1.should == 'parent'
+    @parent.child_documents.collect(&:field_1).should == ['child0', 'child1']
+  end
+
+  it 'can accept an nested attributes with ids' do
+    children = 2.times.map { |i| { :id => BSON::ObjectId.generate, :field_1 => "child#{i}" } }
+    @parent = ParentDocument.create(:field_1 => 'parent',
+                                    :child_documents => children)
+
+    children.each do |child|
+      ChildDocument.find(child[:id]).should.not == nil
+    end
+  end
+
+  it 'can accept array of initialized children' do
+    children = 2.times.map { |i| ChildDocument.new(:field_1 => "child#{i}") }
+    @parent = ParentDocument.create(:field_1 => 'parent',
+                                    :child_documents => children)
+
+    @parent.field_1.should == 'parent'
+    @parent.child_documents.collect(&:field_1).should == ['child0', 'child1']
+  end
+
+  it 'can accept array of created children' do
+    children = 2.times.map { |i| ChildDocument.create(:field_1 => "child#{i}") }
+    @parent = ParentDocument.create(:field_1 => 'parent',
+                                    :child_documents => children)
+
+    @parent.field_1.should == 'parent'
+    @parent.child_documents.collect(&:field_1).should == ['child0', 'child1']
+  end
+
+  it 'can update a child document via nested attributes' do
+    children = 2.times.map { |i| { :id => BSON::ObjectId.generate,
+                                    :field_1 => "child#{i}",
+                                    :field_2 => 'value' } }
+    @parent = ParentDocument.create(:field_1 => 'parent',
+                                    :child_documents => children)
+    @parent.update_attributes(:child_documents => [{ :id      => children[0][:id],
+                                                     :field_1 => 'updated0' },
+                                                   { :id      => children[1][:id],
+                                                     :field_1 => 'updated1' }])
+
+    children.each_with_index do |child, i|
+      ChildDocument.find(child[:id]).field_1.should == "updated#{i}"
+      ChildDocument.find(child[:id]).field_2.should == "value"
+    end
+  end
+
+  it 'can set a parent to nil' do
+    child = ChildDocument.create(:field_1 => 'child_field',
+                                 :parent_document => nil)
+
+    child.field_1.should == 'child_field'
+  end
+
+  describe 'with a parent with many children' do
+    before do
+      @parent = ParentDocument.create(:field_1 => 'parent')
+      3.times { ChildDocument.create(:parent_document => @parent) }
+    end
+
+    it 'the child can access the parent' do
+      @parent.reload
+
+      @parent.child_documents.count.should == 3
+      @parent.child_documents.each { |doc| doc.class.should == ChildDocument }
+    end
+
+    it 'the parent can access the child' do
+      ChildDocument.all.each { |doc| doc.parent_document.id.should == @parent.id }
+    end
+
+    describe 'when a child is destroyed' do
+      before do
+        @last_id = ChildDocument.all.last.id
+        ChildDocument.all.last.destroy
+      end
+
+      it 'the child is removed from the parent' do
+        @parent.reload
+
+        @parent.child_documents.count.should == 2
+        @parent.child_documents.collect(&:id).each { |id| id.should.not == @last_id }
+      end
+    end
+  end
+
+  describe 'with a before_save callback on the child that references the parent document' do
+    before do
+      ChildDocument.class_eval do
+        before_save :set_field_2
+
+        def set_field_2
+          self.field_2 = self.parent_document.id
+        end
+      end
+    end
+
+    it 'includes parent relation in the callback' do
+      @parent = ParentDocument.create(:field_1 => 'parent',
+                                      :child_documents => [{ :field_1 => "value" }])
+
+      @parent.child_documents.first.field_2.should == @parent.id
+    end
+  end
+end
+
+describe 'Yapper document 1:N:1 relationship' do
+  before do
+    class Parent1
+      include Yapper::Document
+
+      field :field_1
+
+      has_many :child_documents
+    end
+    class Parent2
+      include Yapper::Document
+
+      field :field_1
+
+      has_many :child_documents
+    end
+    class ChildDocument
+      include Yapper::Document
+
+      field :field_1
+
+      belongs_to :parent1
+      belongs_to :parent2
+    end
+  end
+  after { Yapper::DB.instance.purge }
+  after { ['Parent1', 'Parent2', 'ChildDocument'].each { |klass| Object.send(:remove_const, klass) } }
+
+  it 'can create child with many parents' do
+    parent1 = Parent1.create(:field_1 => 'parent1')
+    parent2 = Parent2.create(:field_1 => 'parent2')
+
+    child = ChildDocument.create(:parent1 => parent1, :parent2 => parent2)
+
+    child.parent1.field_1.should == 'parent1'
+    child.parent2.field_1.should == 'parent2'
+  end
+end