mongoid 2.0.2 → 2.1.0

data/lib/mongoid/relations/synchronization.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module handles the behaviour for synchronizing foreign keys between
+    # both sides of a many to many relations.
+    module Synchronization
+      extend ActiveSupport::Concern
+
+      # Is the document able to be synced on the inverse side? This is only if
+      # the key has changed and the relation bindings have not been run.
+      #
+      # @example Are the foreign keys syncable?
+      #   document.syncable?(metadata)
+      #
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @return [ true, false ] If we can sync.
+      #
+      # @since 2.1.0
+      def syncable?(metadata)
+        !synced?(metadata.foreign_key) && send(metadata.foreign_key_check)
+      end
+
+      # Get the synced foreign keys.
+      #
+      # @example Get the synced foreign keys.
+      #   document.synced
+      #
+      # @return [ Hash ] The synced foreign keys.
+      #
+      # @since 2.1.0
+      def synced
+        @synced ||= {}
+      end
+
+      # Has the document been synced for the foreign key?
+      #
+      # @todo Change the sync to be key based.
+      #
+      # @example Has the document been synced?
+      #   document.synced?
+      #
+      # @param [ String ] foreign_key The foreign key.
+      #
+      # @return [ true, false ] If we can sync.
+      #
+      # @since 2.1.0
+      def synced?(foreign_key)
+        !!synced[foreign_key]
+      end
+
+      # Update the inverse keys for the relation.
+      #
+      # @example Update the inverse keys
+      #   document.update_inverse_keys(metadata)
+      #
+      # @param [ Metadata ] meta The document metadata.
+      #
+      # @return [ Object ] The updated values.
+      #
+      # @since 2.1.0
+      def update_inverse_keys(meta)
+        old, new = changes[meta.foreign_key]
+        meta.criteria(new - old).add_to_set(meta.inverse_foreign_key, id)
+        meta.criteria(old - new).pull(meta.inverse_foreign_key, id)
+      end
+
+      module ClassMethods #:nodoc:
+
+        # Set up the syncing of many to many foreign keys.
+        #
+        # @example Set up the syncing.
+        #   Person.synced(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @since 2.1.0
+        def synced(metadata)
+          synced_save(metadata)
+        end
+
+        private
+
+        # Set up the sync of inverse keys that needs to happen on a save.
+        #
+        # If the foreign key field has changed and the document is not
+        # synced, $addToSet the new ids, $pull the ones no longer in the
+        # array from the inverse side.
+        #
+        # @example Set up the save syncing.
+        #   Person.synced_save(metadata)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ Class ] The class getting set up.
+        #
+        # @since 2.1.0
+        def synced_save(metadata)
+          tap do
+            set_callback(
+              :save,
+              :after,
+              :if => lambda { |doc| doc.syncable?(metadata) }
+            ) do |doc|
+              doc.update_inverse_keys(metadata)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/relations/targets.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "mongoid/relations/targets/enumerable"

data/lib/mongoid/relations/targets/enumerable.rb

@@ -0,0 +1,329 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Relations #:nodoc:
+    module Targets #:nodoc:
+
+      # This class is the wrapper for all relational associations that have a
+      # target that can be a criteria or array of loaded documents. This
+      # handles both cases or a combination of the two.
+      class Enumerable
+        include ::Enumerable
+
+        # The three main instance variables are collections of documents.
+        #
+        # @attribute [rw] added Documents that have been appended.
+        # @attribute [rw] loaded Persisted documents that have been loaded.
+        # @attribute [rw] unloaded A criteria representing persisted docs.
+        attr_accessor :added, :loaded, :unloaded
+
+        # Check if the enumerable is equal to the other object.
+        #
+        # @example Check equality.
+        #   enumerable == []
+        #
+        # @param [ Enumerable ] other The other enumerable.
+        #
+        # @return [ true, false ] If the objects are equal.
+        #
+        # @since 2.1.0
+        def ==(other)
+          return false unless other.respond_to?(:entries)
+          entries == other.entries
+        end
+
+        # Append a document to the enumerable.
+        #
+        # @example Append the document.
+        #   enumerable << document
+        #
+        # @param [ Document ] document The document to append.
+        #
+        # @return [ Document ] The document.
+        #
+        # @since 2.1.0
+        def <<(document)
+          added << document
+        end
+        alias :push :<<
+
+        # Clears out all the documents in this enumerable. If passed a block it
+        # will yield to each document that is in memory.
+        #
+        # @example Clear out the enumerable.
+        #   enumerable.clear
+        #
+        # @example Clear out the enumerable with a block.
+        #   enumerable.clear do |doc|
+        #     doc.unbind
+        #   end
+        #
+        # @return [ Array<Document> ] The cleared out added docs.
+        #
+        # @since 2.1.0
+        def clear
+          if block_given?
+            in_memory { |doc| yield(doc) }
+          end
+          loaded.clear and added.clear
+        end
+
+        # Delete the supplied document from the enumerable.
+        #
+        # @example Delete the document.
+        #   enumerable.delete(document)
+        #
+        # @param [ Document ] document The document to delete.
+        #
+        # @return [ Document ] The deleted document.
+        #
+        # @since 2.1.0
+        def delete(document)
+          (loaded.delete(document) || added.delete(document)).tap do |doc|
+            unless doc
+              if unloaded && unloaded.where(:_id => document.id).exists?
+                yield(document) if block_given?
+                return document
+              end
+            end
+            yield(doc) if block_given?
+          end
+        end
+
+        # Deletes every document in the enumerable for where the block returns
+        # true.
+        #
+        # @note This operation loads all documents from the database.
+        #
+        # @example Delete all matching documents.
+        #   enumerable.delete_if do |doc|
+        #     dod.id == id
+        #   end
+        #
+        # @return [ Array<Document> ] The remaining docs.
+        #
+        # @since 2.1.0
+        def delete_if(&block)
+          load_all!
+          tap do
+            loaded.delete_if(&block)
+            added.delete_if(&block)
+          end
+        end
+
+        # Iterating over this enumerable has to handle a few different
+        # scenarios.
+        #
+        # If the enumerable has its criteria loaded into memory then it yields
+        # to all the loaded docs and all the added docs.
+        #
+        # If the enumerable has not loaded the criteria then it iterates over
+        # the cursor while loading the documents and then iterates over the
+        # added docs.
+        #
+        # @example Iterate over the enumerable.
+        #   enumerable.each do |doc|
+        #     puts doc
+        #   end
+        #
+        # @return [ true ] That the enumerable is now loaded.
+        #
+        # @since 2.1.0
+        def each
+          if loaded?
+            loaded.each do |doc|
+              yield(doc)
+            end
+          else
+            unloaded.each do |doc|
+              loaded.push(doc)
+              yield(doc)
+            end
+          end
+          added.each do |doc|
+            next unless doc.new?
+            yield(doc)
+          end
+          @executed = true
+        end
+
+        # Is the enumerable empty? Will determine if the count is zero based on
+        # whether or not it is loaded.
+        #
+        # @example Is the enumerable empty?
+        #   enumerable.empty?
+        #
+        # @return [ true, false ] If the enumerable is empty.
+        #
+        # @since 2.1.0
+        def empty?
+          if loaded?
+            in_memory.count == 0
+          else
+            unloaded.count + added.count == 0
+          end
+        end
+
+        # Get the first document in the enumerable. Will check the persisted
+        # documents first. Does not load the entire enumerable.
+        #
+        # @example Get the first document.
+        #   enumerable.first
+        #
+        # @return [ Document ] The first document found.
+        #
+        # @since 2.1.0
+        def first
+          (loaded? ? loaded.first : unloaded.first) || added.first
+        end
+
+        # Initialize the new enumerable either with a criteria or an array.
+        #
+        # @example Initialize the enumerable with a criteria.
+        #   Enumberable.new(Post.where(:person_id => id))
+        #
+        # @example Initialize the enumerable with an array.
+        #   Enumerable.new([ post ])
+        #
+        # @param [ Criteria, Array<Document> ] target The wrapped object.
+        #
+        # @since 2.1.0
+        def initialize(target)
+          if target.is_a?(Criteria)
+            @added, @loaded, @unloaded = [], [], target
+          else
+            @added, @executed, @loaded = [], true, target
+          end
+        end
+
+        # Inspection will just inspect the entries for nice array-style
+        # printing.
+        #
+        # @example Inspect the enumerable.
+        #   enumerable.inspect
+        #
+        # @return [ String ] The inspected enum.
+        #
+        # @since 2.1.0
+        def inspect
+          entries.inspect
+        end
+
+        # Return all the documents in the enumerable that have been loaded or
+        # added.
+        #
+        # @note When passed a block it yields to each document.
+        #
+        # @example Get the in memory docs.
+        #   enumerable.in_memory
+        #
+        # @return [ Array<Document> ] The in memory docs.
+        #
+        # @since 2.1.0
+        def in_memory
+          (loaded + added).tap do |docs|
+            docs.each { |doc| yield(doc) } if block_given?
+          end
+        end
+
+        # Get the last document in the enumerable. Will check the new
+        # documents first. Does not load the entire enumerable.
+        #
+        # @example Get the last document.
+        #   enumerable.last
+        #
+        # @return [ Document ] The last document found.
+        #
+        # @since 2.1.0
+        def last
+          added.last || (loaded? ? loaded.last : unloaded.last)
+        end
+
+        # Loads all the documents in the enumerable from the database.
+        #
+        # @example Load all the documents.
+        #   enumerable.load_all!
+        #
+        # @return [ true ] That the enumerable is loaded.
+        #
+        # @since 2.1.0
+        alias :load_all! :entries
+
+        # Has the enumerable been loaded? This will be true if the criteria has
+        # been executed or we manually load the entire thing.
+        #
+        # @example Is the enumerable loaded?
+        #   enumerable.loaded?
+        #
+        # @return [ true, false ] If the enumerable has been loaded.
+        #
+        # @since 2.1.0
+        def loaded?
+          !!@executed
+        end
+
+        # Reset the enumerable back to it's persisted state.
+        #
+        # @example Reset the enumerable.
+        #   enumerable.reset
+        #
+        # @return [ false ] Always false.
+        #
+        # @since 2.1.0
+        def reset
+          loaded.clear and added.clear
+          @executed = false
+        end
+
+        # Does this enumerable respond to the provided method?
+        #
+        # @example Does the enumerable respond to the method?
+        #   enumerable.respond_to?(:sum)
+        #
+        # @param [ String, Symbol ] name The name of the method.
+        # @param [ true, false ] include_private Whether to include private
+        #   methods.
+        #
+        # @return [ true, false ] Whether the enumerable responds.
+        #
+        # @since 2.1.0
+        def respond_to?(name, include_private = false)
+          [].respond_to?(name, include_private) || super
+        end
+
+        # Gets the total size of this enumerable. This is a combination of all
+        # the persisted and unpersisted documents.
+        #
+        # @example Get the size.
+        #   enumerable.size
+        #
+        # @return [ Integer ] The size of the enumerable.
+        #
+        # @since 2.1.0
+        def size
+          (loaded? ? loaded.count : unloaded.count) + added.count{ |d| d.new? }
+        end
+        alias :length :size
+
+        # Return all the unique documents in the enumerable.
+        #
+        # @note This operation loads all documents from the database.
+        #
+        # @example Get all the unique documents.
+        #   enumerable.uniq
+        #
+        # @return [ Array<Document> ] The unique documents.
+        #
+        # @since 2.1.0
+        def uniq
+          entries.uniq
+        end
+
+        private
+
+        def method_missing(name, *args, &block)
+          entries.send(name, *args, &block)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/safety.rb

@@ -24,7 +24,29 @@ module Mongoid #:nodoc:
     #
     # @return [ Proxy ] The safety proxy.
     def safely(safety = true)
-      Proxy.new(self, safety)
+      tap { Threaded.safety_options = safety }
+    end
+
+    class << self
+
+      # Static class method of easily getting the desired safe mode options
+      # from anywhere in the framework.
+      #
+      # @example Get the options with safe mode included.
+      #   Safety.merge_safety_options({ :safe => false })
+      #
+      # @param [ Hash ] options The persistence options.
+      #
+      # @return [ Hash ] The options hash.
+      #
+      # @since 2.1.0
+      def merge_safety_options(options = {})
+        options ||= {}
+        return options if options[:safe]
+        options.merge!(
+          { :safe => Threaded.safety_options || Mongoid.persist_in_safe_mode }
+        )
+      end
     end
 
     module ClassMethods #:nodoc:
@@ -46,161 +68,7 @@ module Mongoid #:nodoc:
       #
       # @return [ Proxy ] The safety proxy.
       def safely(safety = true)
-        Proxy.new(self, safety)
-      end
-    end
-
-    # When this class proxies a document or class, the next persistence
-    # operation executed on it will query in safe mode.
-    #
-    # Operations that took a hash of attributes had to be somewhat duplicated
-    # here since we do not want to allow a :safe attribute to be included in
-    # the args. This is because safe could be a common attribute name and we
-    # don't want the collision between the attribute and determining whether or
-    # not safe mode is allowed.
-    class Proxy
-
-      attr_reader :target, :safety_options
-
-      # Create a new +Document+. This will instantiate a new document and
-      # insert it in a single call. Will always return the document
-      # whether save passed or not.
-      #
-      # @example Safely create a document.
-      #   Person.safely.create(:title => "Mr")
-      #
-      # @param [ Hash ] attributes The attributes to create with.
-      #
-      # @return [ Document ] The new document.
-      def create(attributes = {})
-        target.new(attributes).tap { |doc| doc.insert(:safe => safety_options) }
-      end
-
-      # Create a new +Document+. This will instantiate a new document and
-      # insert it in a single call. Will always return the document
-      # whether save passed or not, and if validation fails an error will be
-      # raise.
-      #
-      # @example Safely create a document.
-      #   Person.safely.create!(:title => "Mr")
-      #
-      # @param [ Hash ] attributes The attributes to create with.
-      #
-      # @raise [ Errors::Validations ] If validation failed.
-      #
-      # @return [ Document ] If validation passed.
-      def create!(attributes = {})
-        target.new(attributes).tap do |document|
-          fail_validate!(document) if document.insert(:safe => safety_options).errors.any?
-        end
-      end
-
-      # Delete all documents given the supplied conditions. If no conditions
-      # are passed, the entire collection will be dropped for performance
-      # benefits. Does not fire any callbacks.
-      #
-      # @example Delete all documents.
-      #   Person.safely.delete_all
-      #
-      # @example Conditionally delete all documents.
-      #   Person.safely.delete_all(:conditions => { :title => "Sir" })
-      #
-      # @param [ Hash ] conditions The conditions to delete with.
-      #
-      # @return [ Integer ] The number of documents deleted.
-      def delete_all(conditions = {})
-        Mongoid::Persistence::RemoveAll.new(
-          target,
-          { :validate => false, :safe => safety_options },
-          conditions[:conditions] || {}
-        ).persist
-      end
-
-      # destroy all documents given the supplied conditions. If no conditions
-      # are passed, the entire collection will be dropped for performance
-      # benefits. Fires the destroy callbacks if conditions were passed.
-      #
-      # @example destroy all documents.
-      #   Person.safely.destroy_all
-      #
-      # @example Conditionally destroy all documents.
-      #   Person.safely.destroy_all(:conditions => { :title => "Sir" })
-      #
-      # @param [ Hash ] conditions The conditions to destroy with.
-      #
-      # @return [ Integer ] The number of documents destroyd.
-      def destroy_all(conditions = {})
-        documents = target.all(conditions)
-        documents.count.tap do |count|
-          documents.each { |doc| doc.destroy(:safe => safety_options) }
-        end
-      end
-
-      # Increment the field by the provided value, else if it doesn't exists set
-      # it to that value.
-      #
-      # @example Safely increment a field.
-      #   person.safely.inc(:age, 1)
-      #
-      # @param [ Symbol, String ] field The field to increment.
-      # @param [ Integer ] value The value to increment by.
-      # @param [ Hash ] options Options to pass through to the driver.
-      def inc(field, value, options = {})
-        target.inc(field, value, :safe => safety_options)
-      end
-
-      # Create the new +Proxy+.
-      #
-      # @example Create the proxy.
-      #   Proxy.new(document, :w => 3)
-      #
-      # @param [ Document, Class ] target Either the class or the instance.
-      # @param [ true, Hash ] safety_options The options.
-      def initialize(target, safety_options)
-        @target = target
-        @safety_options = safety_options
-      end
-
-      # We will use method missing to proxy calls to the target.
-      #
-      # @example Save safely.
-      #   person.safely.save
-      #
-      # @param [ Array ] *args The arguments to pass on.
-      def method_missing(*args)
-        name = args[0]
-        attributes = args[1] || {}
-        target.send(name, attributes.merge(:safe => safety_options))
-      end
-
-      # Update the +Document+ attributes in the datbase.
-      #
-      # @example Safely update attributes.
-      #   person.safely.update_attributes(:title => "Sir")
-      #
-      # @param [ Hash ] attributes The attributes to update.
-      #
-      # @return [ true, false ] Whether the document was saved.
-      def update_attributes(attributes = {})
-        target.write_attributes(attributes)
-        target.update(:safe => safety_options)
-      end
-
-      # Update the +Document+ attributes in the datbase.
-      #
-      # @example Safely update attributes.
-      #   person.safely.update_attributes(:title => "Sir")
-      #
-      # @param [ Hash ] attributes The attributes to update.
-      #
-      # @raise [ Errors::Validations ] If validation failed.
-      #
-      # @return [ true ] If the document was saved.
-      def update_attributes!(attributes = {})
-        target.write_attributes(attributes)
-        update(:safe => safety_options).tap do |result|
-          target.class.fail_validate!(target) unless result
-        end
+        tap { Threaded.safety_options = safety }
       end
     end
   end