mongodb 0.0.7 → 0.0.8

data/lib/mongo/driver/collection.rb

@@ -5,34 +5,34 @@ module Mongo::CollectionExt
   #
   # CRUD
   #
-  def save_with_ext doc, opts = {}
-    save_without_ext doc, reverse_merge_defaults(opts, :safe)
+  def save_with_ext doc, options = {}
+    save_without_ext doc, reverse_merge_defaults(options, :safe)
   end
 
-  def insert_with_ext args, opts = {}
-    result = insert_without_ext args, reverse_merge_defaults(opts, :safe)
+  def insert_with_ext args, options = {}
+    result = insert_without_ext args, reverse_merge_defaults(options, :safe)
 
     # fix for mongodriver, it will return single result if we supply [doc] as args
     (args.is_a?(Array) and !result.is_a?(Array)) ? [result] : result
   end
 
-  def update_with_ext selector, doc, opts = {}
+  def update_with_ext selector, doc, options = {}
     selector = convert_underscore_to_dollar_in_selector selector
     doc      = convert_underscore_to_dollar_in_update doc
 
     # because :multi works only with $ operators, we need to check if it's applicable
-    opts = if doc.keys.any?{|k| k =~ /^\$/}
-      reverse_merge_defaults(opts, :safe, :multi)
+    options = if doc.keys.any?{|k| k =~ /^\$/}
+      reverse_merge_defaults(options, :safe, :multi)
     else
-      reverse_merge_defaults(opts, :safe)
+      reverse_merge_defaults(options, :safe)
     end
 
-    update_without_ext selector, doc, opts
+    update_without_ext selector, doc, options
   end
 
-  def remove_with_ext selector = {}, opts = {}
+  def remove_with_ext selector = {}, options = {}
     selector = convert_underscore_to_dollar_in_selector selector
-    remove_without_ext selector, reverse_merge_defaults(opts, :safe, :multi)
+    remove_without_ext selector, reverse_merge_defaults(options, :safe, :multi)
   end
 
   def destroy *args
@@ -46,33 +46,33 @@ module Mongo::CollectionExt
   #
   # Querying
   #
-  def first selector = {}, opts = {}
+  def first selector = {}, options = {}
     selector = convert_underscore_to_dollar_in_selector selector if selector.is_a? Hash
 
-    h = find_one selector, opts
+    h = find_one selector, options
     symbolize_doc h
   end
 
-  def first! selector = {}, opts = {}
-    first(selector, opts) || raise(Mongo::NotFound, "document with selector #{selector} not found!")
+  def first! selector = {}, options = {}
+    first(selector, options) || raise(Mongo::NotFound, "document with selector #{selector} not found!")
   end
 
-  def all selector = {}, opts = {}, &block
+  def all selector = {}, options = {}, &block
     if block
-      each selector, opts, &block
+      each selector, options, &block
     else
       list = []
-      each(selector, opts){|doc| list << doc}
+      each(selector, options){|doc| list << doc}
       list
     end
   end
 
-  def each selector = {}, opts = {}, &block
+  def each selector = {}, options = {}, &block
     selector = convert_underscore_to_dollar_in_selector selector
 
     cursor = nil
     begin
-      cursor = find selector, reverse_merge_defaults(opts, :batch_size)
+      cursor = find selector, reverse_merge_defaults(options, :batch_size)
       cursor.each do |doc|
         doc = symbolize_doc doc
         block.call doc
@@ -84,8 +84,8 @@ module Mongo::CollectionExt
     nil
   end
 
-  def count_with_ext selector = {}, opts = {}
-    find(selector, opts).count()
+  def count_with_ext selector = {}, options = {}
+    find(selector, options).count()
   end
 
   protected
@@ -100,8 +100,8 @@ module Mongo::CollectionExt
       :_inc, :_set, :_unset, :_push, :_pushAll, :_addToSet, :_pop, :_pull, :_pullAll, :_rename, :_bit
     ].to_set
 
-    def reverse_merge_defaults opts, *keys
-      h = opts.clone
+    def reverse_merge_defaults options, *keys
+      h = options.clone
       keys.each do |k|
         h[k] = Mongo.defaults[k] if Mongo.defaults.include?(k) and !h.include?(k)
       end

data/lib/mongo/object/object.rb

@@ -1,23 +1,23 @@
 module Mongo::Object
-  attr_accessor :_id
+  attr_accessor :_id, :_parent
 
-  def valid? opts = {}
-    opts = ::Mongo::Object.parse_options opts
+  def valid? options = {}
+    options = ::Mongo::Object.parse_options options
     begin
-      return false if opts[:callbacks] and !::Mongo::Object.run_before_callbacks(self, :validate)
+      return false if options[:callbacks] and !::Mongo::Object.run_before_callbacks(self, :validate)
 
-      child_opts = opts.merge internal: true
+      child_options = options.merge internal: true
       result = [
-        child_objects.all?{|group| group.all?{|obj| obj.valid?(child_opts)}},
+        child_objects.all?{|group| group.all?{|obj| obj.valid?(child_options)}},
         ::Mongo::Object.run_validations(self),
         errors.empty?
       ].all?
 
-      ::Mongo::Object.run_after_callbacks(self, :validate) if opts[:callbacks]
+      ::Mongo::Object.run_after_callbacks(self, :validate) if options[:callbacks]
 
       result
     ensure
-      clear_child_objects unless opts[:internal]
+      clear_child_objects unless options[:internal]
     end
   end
 
@@ -25,34 +25,34 @@ module Mongo::Object
     @_errors ||= {}
   end
 
-  def create_object collection, opts
-    with_object_callbacks :create, opts do |opts|
+  def create_object collection, options
+    with_object_callbacks :create, options do |options|
       doc = ::Mongo::Object.to_mongo self
-      collection.create(doc, opts)
+      collection.create(doc, options)
       self._id = doc[:_id] || doc['_id']
     end
   end
 
-  def update_object collection, opts
-    with_object_callbacks :update, opts do |opts|
+  def update_object collection, options
+    with_object_callbacks :update, options do |options|
       id = _id || "can't update object without _id (#{self})!"
       doc = ::Mongo::Object.to_mongo self
-      collection.update({_id: id}, doc, opts)
+      collection.update({_id: id}, doc, options)
     end
   end
 
-  def destroy_object collection, opts
-    with_object_callbacks :destroy, opts do |opts|
+  def destroy_object collection, options
+    with_object_callbacks :destroy, options do |options|
       id = _id || "can't destroy object without _id (#{self})!"
-      collection.destroy({_id: id}, opts)
+      collection.destroy({_id: id}, options)
     end
   end
 
-  def save_object collection, opts
+  def save_object collection, options
     if _id
-      update_object collection, opts
+      update_object collection, options
     else
-      create_object collection, opts
+      create_object collection, options
     end
   end
 
@@ -61,21 +61,21 @@ module Mongo::Object
   SKIP_IV_REGEXP = /^@_/
 
   class << self
-    def parse_options opts
-      opts = opts.clone
-      opts[:validate]  = true                       unless opts.include?(:validate)
-      opts[:callbacks] = Mongo.defaults[:callbacks] unless opts.include?(:callbacks)
-      return opts
+    def parse_options options
+      options = options.clone
+      options[:validate]  = true                       unless options.include?(:validate)
+      options[:callbacks] = Mongo.defaults[:callbacks] unless options.include?(:callbacks)
+      return options
     end
 
-    def to_mongo_options opts
-      opts = opts.clone
-      opts.delete :validate
-      opts.delete :callbacks
-      opts
+    def to_mongo_options options
+      options = options.clone
+      options.delete :validate
+      options.delete :callbacks
+      options
     end
 
-    def each_instance_variable obj, &block
+    def each_object_instance_variable obj, &block
       obj.instance_variables.each do |iv_name|
         # skipping variables starting with _xx, usually they
         # have specific meaning and used for example for cache
@@ -102,7 +102,7 @@ module Mongo::Object
         doc = {}
 
         # copying instance variables
-        each_instance_variable obj do |iv_name, v|
+        each_object_instance_variable obj do |iv_name, v|
           k = iv_name.to_s[1..-1]
           k = k.to_sym if symbolize
           doc[k] = to_mongo v
@@ -127,7 +127,7 @@ module Mongo::Object
         obj.each{|v| each_object v, &block}
       elsif obj.is_a? ::Mongo::Object
         block.call obj if include_first
-        each_instance_variable obj do |iv_name, v|
+        each_object_instance_variable obj do |iv_name, v|
           each_object v, &block
         end
       end
@@ -136,7 +136,7 @@ module Mongo::Object
 
     def build doc
       return unless doc
-      obj = _build doc
+      obj = _build doc, nil
       obj.send :update_original_children! if obj.is_a? ::Mongo::Object
       obj
     end
@@ -164,28 +164,33 @@ module Mongo::Object
     end
 
     protected
-      def _build doc
+      def _build doc, parent = nil
         if doc.is_a? Hash
           if class_name = doc[:_class] || doc['_class']
             klass = constantize class_name
 
             if klass.respond_to? :from_mongo
-              klass.from_mongo doc
+              obj = klass.from_mongo doc
             else
               obj = klass.new
+              parent ||= obj
               doc.each do |k, v|
                 next if k.to_sym == :_class
 
-                v = _build v
+                v = _build v, parent
                 obj.instance_variable_set "@#{k}", v
               end
               obj
             end
+            obj._parent = parent if parent
+            obj
           else
-            doc
+            hash = {}
+            doc.each{|k, v| hash[k] = _build v, parent}
+            hash
           end
         elsif doc.is_a? Array
-          doc.collect{|v| _build v}
+          doc.collect{|v| _build v, parent}
         else
           doc
         end
@@ -240,21 +245,21 @@ module Mongo::Object
       @_child_objects
     end
 
-    def with_object_callbacks method, opts, &block
-      opts = ::Mongo::Object.parse_options opts
+    def with_object_callbacks method, options, &block
+      options = ::Mongo::Object.parse_options options
 
       # validation
-      return false if opts[:validate] and !valid?(opts.merge(internal: true))
+      return false if options[:validate] and !valid?(options.merge(internal: true))
 
       # before callbacks
-      return false if opts[:callbacks] and !run_all_callbacks(:before, method)
+      return false if options[:callbacks] and !run_all_callbacks(:before, method)
 
       # saving
-      block.call ::Mongo::Object.to_mongo_options(opts)
+      block.call ::Mongo::Object.to_mongo_options(options)
       update_original_children!
 
       # after callbacks
-      run_all_callbacks :after, method if opts[:callbacks]
+      run_all_callbacks :after, method if options[:callbacks]
 
       true
     ensure

data/lib/mongo/object/object_helper.rb

@@ -2,37 +2,37 @@ module Mongo::ObjectHelper
   #
   # CRUD
   #
-  def create_with_object doc, opts = {}
+  def create_with_object doc, options = {}
     if doc.is_a? ::Mongo::Object
-      doc.create_object self, opts
+      doc.create_object self, options
     else
-      create_without_object doc, opts
+      create_without_object doc, options
     end
   end
 
   def update_with_object *args
     if args.first.is_a? ::Mongo::Object
-      doc, opts = args
-      opts ||= {}
-      doc.update_object self, opts
+      doc, options = args
+      options ||= {}
+      doc.update_object self, options
     else
       update_without_object *args
     end
   end
 
-  def save_with_object doc, opts = {}
+  def save_with_object doc, options = {}
     if doc.is_a? ::Mongo::Object
-      doc.save_object self, opts
+      doc.save_object self, options
     else
-      save_without_object doc, opts
+      save_without_object doc, options
     end
   end
 
   def destroy_with_object *args
     if args.first.is_a? ::Mongo::Object
-      doc, opts = args
-      opts ||= {}
-      doc.destroy_object self, opts
+      doc, options = args
+      options ||= {}
+      doc.destroy_object self, options
     else
       destroy_without_object *args
     end
@@ -58,21 +58,21 @@ module Mongo::ObjectHelper
   #
   # Querying
   #
-  def first selector = {}, opts = {}, &block
-    opts = opts.clone
-    if opts.delete(:object) == false
-      super selector, opts, &block
+  def first selector = {}, options = {}, &block
+    options = options.clone
+    if options.delete(:object) == false
+      super selector, options, &block
     else
-      ::Mongo::Object.build super(selector, opts, &block)
+      ::Mongo::Object.build super(selector, options, &block)
     end
   end
 
-  def each selector = {}, opts = {}, &block
-    opts = opts.clone
-    if opts.delete(:object) == false
-      super selector, opts, &block
+  def each selector = {}, options = {}, &block
+    options = options.clone
+    if options.delete(:object) == false
+      super selector, options, &block
     else
-      super selector, opts do |doc|
+      super selector, options do |doc|
         block.call ::Mongo::Object.build(doc)
       end
     end

data/lib/mongo/object/spec.rb

@@ -1,4 +1,6 @@
+require 'mongo/object'
 require 'mongo/driver/spec'
 
 # RSpec adds some instance variables and we need to skip it.
+Mongo::Object.send :remove_const, :SKIP_IV_REGEXP
 Mongo::Object.send :const_set, :SKIP_IV_REGEXP, /^@_|^@mock_proxy/

data/lib/mongo/object/spec/crud_shared.rb

@@ -40,7 +40,11 @@ shared_examples_for 'embedded object CRUD' do
 
     # update
     @player.missions.first.stats[:units] = 9
-    @player.missions << @mission_class.new('Desperate Alliance', {buildings: 11, units: 40})
+    mission = @mission_class.new.tap do |m|
+      m.name = 'Desperate Alliance'
+      m.stats = {buildings: 11, units: 40}
+    end
+    @player.missions << mission
     db.players.save @player
     db.players.count.should == 1
     db.players.first.should == @player
@@ -50,4 +54,10 @@ shared_examples_for 'embedded object CRUD' do
     db.players.destroy @player
     db.players.count.should == 0
   end
+
+  it "embedded object should have :_parent reference to the main object" do
+    db.players.save @player
+    player = db.players.first
+    player.missions.first._parent.should == player
+  end
 end

data/spec/object/spec_helper.rb

@@ -7,12 +7,12 @@ require 'driver/spec_helper'
 
 # To simplify callback expectations
 module RSpec::CallbackHelper
-  def run_before_callbacks method_name, opts = {}
+  def run_before_callbacks method_name, options = {}
     callback_method_name = :"before_#{method_name}"
     respond_to?(callback_method_name) ? send(callback_method_name) : true
   end
 
-  def run_after_callbacks method_name, opts = {}
+  def run_after_callbacks method_name, options = {}
     callback_method_name = :"after_#{method_name}"
     respond_to?(callback_method_name) ? send(callback_method_name) : true
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongodb
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-30 00:00:00.000000000Z
+date: 2011-09-02 00:00:00.000000000Z
 dependencies: []
 description: 
 email: