mongoid-rails2 1.9.3

data/lib/mongoid/matchers/lte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lte < Default
+      # Return true if the attribute is less than or equal to the value.
+      def matches?(value)
+        determine(value, :<=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/ne.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Ne < Default
+      # Return true if the attribute and first value are not equal.
+      def matches?(value)
+        @attribute != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/nin.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Nin < Default
+      # Return true if the attribute is not in the value list.
+      def matches?(value)
+        !value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/size.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Size < Default
+      # Return true if the attribute size is equal to the first value.
+      def matches?(value)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+require "mongoid/matchers/default"
+require "mongoid/matchers/all"
+require "mongoid/matchers/exists"
+require "mongoid/matchers/gt"
+require "mongoid/matchers/gte"
+require "mongoid/matchers/in"
+require "mongoid/matchers/lt"
+require "mongoid/matchers/lte"
+require "mongoid/matchers/ne"
+require "mongoid/matchers/nin"
+require "mongoid/matchers/size"
+
+module Mongoid #:nodoc:
+  module Matchers
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        return false unless matcher(key, value).matches?(value)
+      end
+      true
+    end
+
+    protected
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    def matcher(key, value)
+      if value.is_a?(Hash)
+        name = "Mongoid::Matchers::#{value.keys.first.gsub("$", "").camelize}"
+        return name.constantize.new(attributes[key])
+      end
+      Default.new(attributes[key])
+    end
+  end
+end

data/lib/mongoid/memoization.rb

@@ -0,0 +1,33 @@
+module Mongoid #:nodoc
+  module Memoization
+
+    # Handles cases when accessing an association that should be memoized in
+    # the Mongoid specific manner. Does not memoize nil values though
+    def memoized(name, &block)
+      var = "@#{name}"
+      if instance_variable_defined?(var)
+        return instance_variable_get(var)
+      end
+      value = yield
+      instance_variable_set(var, value) if value
+    end
+
+    # Removes an memozied association if it exists
+    def unmemoize(name)
+      var = "@#{name}"
+      remove_instance_variable(var) if instance_variable_defined?(var)
+    end
+
+    # Mongoid specific behavior is to remove the memoized object when setting
+    # the association, or if it wasn't previously memoized it will get set.
+    def reset(name, &block)
+      var = "@#{name}"
+      value = yield
+      if instance_variable_defined?(var)
+        remove_instance_variable(var)
+      else
+        instance_variable_set(var, value)
+      end
+    end
+  end
+end

data/lib/mongoid/named_scope.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module NamedScope
+    # Creates a named_scope for the +Document+, similar to ActiveRecord's
+    # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+    # chained.
+    #
+    # Example:
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :active, :type => Boolean
+    #     field :count, :type => Integer
+    #
+    #     named_scope :active, :where => { :active => true }
+    #     named_scope :count_gt_one, :where => { :count.gt => 1 }
+    #     named_scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+    #   end
+    def named_scope(name, options = {}, &block)
+      name = name.to_sym
+      scopes[name] = lambda do |parent, *args|
+        Scope.new(parent, options.scoped(*args), &block)
+      end
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scopes[:#{name}].call(self, *args)
+        end
+      EOT
+    end
+    alias :scope :named_scope
+
+    # Return the scopes or default to an empty +Hash+.
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+  end
+end

data/lib/mongoid/observable.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Observable #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      attr_reader :observers
+    end
+
+    # Add an observer to this object. This mimics the standard Ruby observable
+    # library.
+    #
+    # Example:
+    #
+    # <tt>address.add_observer(person)</tt>
+    def add_observer(object)
+      @observers ||= []
+      @observers.push(object)
+    end
+
+    # Notify all the objects observing this object of an update. All observers
+    # need to respond to the update method in order to handle this.
+    #
+    # Example:
+    #
+    # <tt>document.notify_observers(self)</tt>
+    def notify_observers(*args)
+      @observers.dup.each { |observer| observer.observe(*args) } if @observers
+    end
+  end
+end

data/lib/mongoid/paths.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Paths #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      attr_accessor :__path
+      attr_accessor :_index
+    end
+    module InstanceMethods
+      # Get the insertion modifier for the document. Will be nil on root
+      # documents, $set on embeds_one, $push on embeds_many.
+      #
+      # Example:
+      #
+      # <tt>name.inserter</tt>
+      def _inserter
+        embedded? ? (embedded_many? ? "$push" : "$set") : nil
+      end
+
+      # Return the path to this +Document+ in JSON notation, used for atomic
+      # updates via $set in MongoDB.
+      #
+      # Example:
+      #
+      # <tt>address.path # returns "addresses"</tt>
+      def _path
+        _position.sub!(/\.\d+$/, '') || _position
+      end
+      alias :_pull :_path
+
+      # Returns the positional operator of this document for modification.
+      #
+      # Example:
+      #
+      # <tt>address.position</tt>
+      def _position
+        locator = _index ? (new_record? ? "" : ".#{_index}") : ""
+        embedded? ? "#{_parent._position}#{"." unless _parent._position.blank?}#{@association_name}#{locator}" : ""
+      end
+
+      # Get the removal modifier for the document. Will be nil on root
+      # documents, $unset on embeds_one, $set on embeds_many.
+      #
+      # Example:
+      #
+      # <tt>name.remover</tt>
+      def _remover
+        embedded? ? (_index ? "$pull" : "$unset") : nil
+      end
+
+      # Return the selector for this document to be matched exactly for use
+      # with MongoDB's $ operator.
+      #
+      # Example:
+      #
+      # <tt>address.selector</tt>
+      def _selector
+        embedded? ? _parent._selector.merge("#{_path}._id" => id) : { "_id" => id }
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/command.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Persistence commands extend from this class to get basic functionality on
+    # initialization.
+    class Command
+      attr_reader \
+        :collection,
+        :document,
+        :klass,
+        :options,
+        :selector,
+        :validate
+
+      # Initialize the persistence +Command+.
+      #
+      # Options:
+      #
+      # document_or_class: The +Document+ or +Class+ to get the collection.
+      # validate: Is the document to be validated.
+      # selector: Optional selector to use in query.
+      #
+      # Example:
+      #
+      # <tt>DeleteAll.new(Person, false, {})</tt>
+      def initialize(document_or_class, validate = true, selector = {})
+        if document_or_class.is_a?(Mongoid::Document)
+          @document = document_or_class
+          @collection = @document.embedded? ? @document._root.collection : @document.collection
+        else
+          @klass = document_or_class
+          @collection = @klass.collection
+        end
+        @selector, @validate = selector, validate
+        @options = { :safe => Mongoid.persist_in_safe_mode }
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/insert.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Insert is a persistence command responsible for taking a document that
+    # has not been saved to the database and saving it.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.insert(
+    #     { "_id" : 1, "field" : "value" },
+    #     false
+    #   );
+    class Insert < Command
+      # Insert the new document in the database. This delegates to the standard
+      # MongoDB collection's insert command.
+      #
+      # Example:
+      #
+      # <tt>Insert.persist</tt>
+      #
+      # Returns:
+      #
+      # The +Document+, whether the insert succeeded or not.
+      def persist
+        return @document if @validate && !@document.valid?
+        @document.run_callbacks(:before_create)
+        @document.run_callbacks(:before_save)
+        if insert
+          @document.new_record = false
+          # TODO: All child document new_record flags must get set to false
+          # here or somewhere - this will cause problems.
+          @document.move_changes
+          @document.run_callbacks(:after_create)
+          @document.run_callbacks(:after_save)
+        end
+        @document
+      end
+
+      protected
+      # Insert the document into the database.
+      def insert
+        if @document.embedded?
+          Persistence::InsertEmbedded.new(@document, @validate).persist
+        else
+          @collection.insert(@document.raw_attributes, @options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/insert_embedded.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Insert is a persistence command responsible for taking a document that
+    # has not been saved to the database and saving it. This specific class
+    # handles the case when the document is embedded in another.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.insert(
+    #     { "_id" : 1, "field" : "value" },
+    #     false
+    #   );
+    class InsertEmbedded < Command
+      # Insert the new document in the database. If the document's parent is a
+      # new record, we will call save on the parent, otherwise we will $push
+      # the document onto the parent.
+      #
+      # Example:
+      #
+      # <tt>Insert.persist</tt>
+      #
+      # Returns:
+      #
+      # The +Document+, whether the insert succeeded or not.
+      def persist
+        parent = @document._parent
+        if parent.new_record?
+          parent.insert
+        else
+          update = { @document._inserter => { @document._position => @document.raw_attributes } }
+          @collection.update(parent._selector, update, @options.merge(:multi => false))
+        end
+        @document.new_record = false; @document
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "_id" : 1 },
+    #     false
+    #   );
+    class Remove < Command
+      # Remove the document from the database: delegates to the MongoDB
+      # collection remove method.
+      #
+      # Example:
+      #
+      # <tt>Remove.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ if success, +false+ if not.
+      def persist
+        remove
+      end
+
+      protected
+      # Remove the document from the database.
+      def remove
+        if @document.embedded?
+          Persistence::RemoveEmbedded.new(@document, @validate).persist
+        else
+          @collection.remove({ :_id => @document.id }, @options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove_all.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "field" : value },
+    #     false
+    #   );
+    class RemoveAll < Command
+      # Remove the document from the database: delegates to the MongoDB
+      # collection remove method.
+      #
+      # Example:
+      #
+      # <tt>Remove.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ if success, +false+ if not.
+      def persist
+        remove
+      end
+
+      protected
+      # Remove the document from the database.
+      def remove
+        count = @collection.find(@selector.merge(:_type => @klass.name)).count
+        @collection.remove(@selector, @options)
+        count
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/remove_embedded.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Remove is a persistence command responsible for deleting a document from
+    # the database.
+    #
+    # The underlying query resembles the following MongoDB query:
+    #
+    #   collection.remove(
+    #     { "_id" : 1 },
+    #     false
+    #   );
+    class RemoveEmbedded < Command
+      # Insert the new document in the database. If the document's parent is a
+      # new record, we will call save on the parent, otherwise we will $push
+      # the document onto the parent.
+      #
+      # Remove the document from the database. If the parent is a new record,
+      # it will get removed in Ruby only. If the parent is not a new record
+      # then either an $unset or $set will occur, depending if it's an
+      # embeds_one or embeds_many.
+      #
+      # Example:
+      #
+      # <tt>RemoveEmbedded.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ or +false+, depending on if the removal passed.
+      def persist
+        parent = @document._parent
+        parent.remove(@document)
+        unless parent.new_record?
+          update = { @document._remover => removal_selector }
+          @collection.update(parent._selector, update, @options.merge(:multi => false))
+        end; true
+      end
+
+      protected
+      # Get the value to pass to the removal modifier.
+      def setter
+        @document._index ? @document.id : true
+      end
+
+      def removal_selector
+        @document._index ? { @document._pull => { "_id" => @document.id } } : { @document._path => setter }
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/update.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Update is a persistence command responsible for taking a document that
+    # has already been saved to the database and saving it, depending on
+    # whether or not the document has been modified.
+    #
+    # Before persisting the command will check via dirty attributes if the
+    # document has changed, if not, it will simply return true. If it has it
+    # will go through the validation steps, run callbacks, and set the changed
+    # fields atomically on the document. The underlying query resembles the
+    # following MongoDB query:
+    #
+    #   collection.update(
+    #     { "_id" : 1,
+    #     { "$set" : { "field" : "value" },
+    #     false,
+    #     false
+    #   );
+    #
+    # For embedded documents it will use the positional locator:
+    #
+    #   collection.update(
+    #     { "_id" : 1, "addresses._id" : 2 },
+    #     { "$set" : { "addresses.$.field" : "value" },
+    #     false,
+    #     false
+    #   );
+    #
+    class Update < Command
+      # Persist the document that is to be updated to the database. This will
+      # only write changed fields via MongoDB's $set modifier operation.
+      #
+      # Example:
+      #
+      # <tt>Update.persist</tt>
+      #
+      # Returns:
+      #
+      # +true+ or +false+, depending on validation.
+      def persist
+        return false if validate && !@document.valid?
+        @document.run_callbacks(:before_save)
+        @document.run_callbacks(:before_update)
+        if update
+          @document.move_changes
+          @document.run_callbacks(:after_save)
+          @document.run_callbacks(:after_update)
+        else
+          return false
+        end; true
+      end
+
+      protected
+      # Update the document in the database atomically.
+      def update
+        if @document.changed?
+          @collection.update(@document._selector, { "$set" => @document.setters }, @options.merge(:multi => false))
+        end; true
+      end
+    end
+  end
+end