mongoid-pre 2.0.0.beta1

data/lib/mongoid/matchers/in.rb

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

data/lib/mongoid/matchers/lt.rb

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

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/memoization.rb

@@ -0,0 +1,27 @@
+module Mongoid #:nodoc
+  module Memoization
+
+    # Handles cases when accessing an association that should be memoized in
+    # the Mongoid specific manner.
+    def memoized(name, &block)
+      var = "@#{name}"
+      if instance_variable_defined?(var)
+        return instance_variable_get(var)
+      end
+      value = yield
+      instance_variable_set(var, value)
+    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,42 @@
+# 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 
+
+    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,54 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Paths #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :_path, :_position
+      delegate :_path, :_position, :to => "self.class"
+    end
+    module InstanceMethods
+      # 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
+        self._path ||= climb("") do |document, value|
+          value = "#{document.association_name}#{"." + value unless value.blank?}"
+        end
+      end
+
+      # Returns the positional operator of this document for modification.
+      #
+      # Example:
+      #
+      # <tt>address.position</tt>
+      def position
+        self._position ||= (path.blank? ? "" : "#{path}.$")
+      end
+
+      # Return the selector for this document to be matched exactly for use
+      # with MongoDB's $ operator.
+      #
+      # Example:
+      #
+      # <tt>address.selector</tt>
+      def selector
+        @selector ||= climb({ "_id" => _root.id }) do |document, value|
+          value["#{document.path}._id"] = document.id; value
+        end
+      end
+
+      protected
+      def climb(value, &block)
+        document = self;
+        while (document._parent) do
+          value = yield document, value
+          document = document._parent
+        end
+        value
+      end
+    end
+  end
+end

data/lib/mongoid/persistence.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+require "mongoid/persistence/command"
+require "mongoid/persistence/insert"
+require "mongoid/persistence/update"
+
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Insert a new +Document+ into the database. Will return the document
+    # itself whether or not the save was successful.
+    #
+    # Example:
+    #
+    # <tt>document.insert</tt>
+    def insert
+      Insert.new(self).persist
+    end
+
+    # Update the +Document+ in the datbase.
+    #
+    # Example:
+    #
+    # <tt>document.update</tt>
+    def update
+      Update.new(self).persist
+    end
+  end
+end

data/lib/mongoid/persistence/command.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Persistence #:nodoc:
+    # Mixin for common functionality for all persistence commands.
+    module Command
+      attr_reader :collection, :document, :options, :validate
+      # Initialize the persistence +Command+.
+      #
+      # Options:
+      #
+      # document: The +Document+ to be persisted.
+      # validate: Is the document to be validated.
+      def init(document, validate)
+        @collection = document.embedded ? document._root.collection : document.collection
+        @document = document
+        @validate = validate
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/insert.rb

@@ -0,0 +1,71 @@
+# 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
+      include Persistence::Command
+
+      # Create the new insert persister.
+      #
+      # Options:
+      #
+      # document: The +Document+ to persist.
+      # validate: +Boolean+ to validate or not.
+      #
+      # Example:
+      #
+      # <tt>Insert.new(document)</tt>
+      def initialize(document, validate = true)
+        init(document, validate)
+        @options = { :safe => Mongoid.persist_in_safe_mode }
+      end
+
+      # 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(:create, :save) do
+          @document.new_record = false if insert
+          @document
+        end
+      end
+
+      protected
+      # Insert the document into the database.
+      def insert
+        if @document.embedded
+          insert_embedded
+        else
+          collection.insert(@document.raw_attributes, options)
+        end
+      end
+
+      # Logic for determining how to insert the embedded doc.
+      def insert_embedded
+        parent = @document._parent
+        if parent.new_record?
+          @document.notify_observers(document, true); parent.insert
+        else
+          update = { @document.path => { "$push" => @document.raw_attributes } }
+          collection.update(parent.selector, update, @options)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/persistence/update.rb

@@ -0,0 +1,78 @@
+# 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
+      include Persistence::Command
+
+      # Create the new update persister.
+      #
+      # Options:
+      #
+      # document: The +Document+ to persist.
+      # validate: +Boolean+ to validate or not.
+      #
+      # Example:
+      #
+      # <tt>Update.new(document)</tt>
+      def initialize(document, validate = true)
+        init(document, validate)
+        @options = { :multi => false, :safe => Mongoid.persist_in_safe_mode }
+      end
+
+      # 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
+        if @document.changed?
+          return false if validate && !@document.valid?
+          @document.run_callbacks(:save, :update) do
+            if update
+              @document.move_changes
+            else
+              return false
+            end
+          end
+        end; true
+      end
+
+      protected
+      # Update the document in the database atomically.
+      def update
+        collection.update(@document.selector, { "$set" => @document.setters }, @options)
+      end
+    end
+  end
+end

data/lib/mongoid/scope.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Scope #:nodoc:
+
+    delegate :scopes, :to => :parent
+
+    attr_reader :parent, :conditions
+
+    # If the other is a scope then compare the parent and conditions, otherwise
+    # if its enumerable collect and compare.
+    def ==(other)
+      case other
+      when Scope
+        @parent == other.parent && @conditions == other.conditions
+      when Enumerable
+        @collection ||= entries
+        return (@collection == other)
+      else
+        return false
+      end
+    end
+
+    # Create the new +Scope+. If a block is passed in, this Scope will extend
+    # the block.
+    #
+    # Options:
+    #
+    # parent: The class the scope belongs to, or a parent +Scope+.
+    # conditions: A +Hash+ of conditions.
+    #
+    # Example:
+    #
+    #   Mongoid::Scope.new(Person, { :title => "Sir" }) do
+    #     def knighted?
+    #       title == "Sir"
+    #     end
+    #   end
+    def initialize(parent, conditions, &block)
+      @parent, @conditions = parent, conditions
+      extend Module.new(&block) if block_given?
+    end
+
+    # Return the class for the +Scope+. This will be the parent if the parent
+    # is a class, otherwise will be nil.
+    def klass
+      @klass ||= @parent unless @parent.is_a?(Scope)
+    end
+
+    # Chaining is supported through method_missing. If a scope is already
+    # defined with the method name the call will be passed there, otherwise it
+    # will be passed to the target or parent.
+    def method_missing(name, *args, &block)
+      if scopes.include?(name)
+        scopes[name].call(self, *args)
+      elsif klass
+        target.send(name, *args, &block)
+      else
+        @parent.fuse(@conditions); @parent.send(name, *args, &block)
+      end
+    end
+
+    # The +Scope+ must respond like a +Criteria+ object. If this is a parent
+    # criteria delegate to the target, otherwise bubble up to the parent.
+    def respond_to?(name)
+      super || (klass ? target.respond_to?(name) : @parent.respond_to?(name))
+    end
+
+    # Returns the target criteria if it has already been set or creates a new
+    # criteria from the parent class.
+    def target
+      @target ||= klass.criteria.fuse(@conditions)
+    end
+  end
+end
+