mongoid-rails2 1.9.3

data/lib/mongoid/persistence.rb

@@ -0,0 +1,222 @@
+# encoding: utf-8
+require "mongoid/persistence/command"
+require "mongoid/persistence/insert"
+require "mongoid/persistence/insert_embedded"
+require "mongoid/persistence/remove"
+require "mongoid/persistence/remove_all"
+require "mongoid/persistence/remove_embedded"
+require "mongoid/persistence/update"
+
+module Mongoid #:nodoc:
+  # The persistence module is a mixin to provide database accessor methods for
+  # the document. These correspond to the appropriate accessors on a
+  # +Mongo::Collection+ and retain the same DSL.
+  #
+  # Examples:
+  #
+  # <tt>document.insert</tt>
+  # <tt>document.update</tt>
+  # <tt>document.upsert</tt>
+  module Persistence
+    extend ActiveSupport::Concern
+    module InstanceMethods #:nodoc:
+      # Remove the +Document+ from the datbase with callbacks.
+      #
+      # Example:
+      #
+      # <tt>document.destroy</tt>
+      #
+      # TODO: Will get rid of other #destroy once new persistence complete.
+      def destroy
+        run_callbacks(:before_destroy)
+        if _remove
+          self.destroyed = true
+          run_callbacks(:after_destroy)
+        end; true
+      end
+
+      # 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(validate = true)
+        Insert.new(self, validate).persist
+      end
+
+      # Remove the +Document+ from the datbase.
+      #
+      # Example:
+      #
+      # <tt>document._remove</tt>
+      #
+      # TODO: Will get rid of other #remove once observable pattern killed.
+      def _remove
+        Remove.new(self).persist
+      end
+
+      alias :delete :_remove
+
+      # Save the document - will perform an insert if the document is new, and
+      # update if not. If a validation error occurs a
+      # Mongoid::Errors::Validations error will get raised.
+      #
+      # Example:
+      #
+      # <tt>document.save!</tt>
+      #
+      # Returns:
+      #
+      # +true+ if validation passed, will raise error otherwise.
+      def save!
+        self.class.fail_validate!(self) unless upsert; true
+      end
+
+      # Update the +Document+ in the datbase.
+      #
+      # Example:
+      #
+      # <tt>document.update</tt>
+      def update(validate = true)
+        Update.new(self, validate).persist
+      end
+
+      # Update the +Document+ attributes in the datbase.
+      #
+      # Example:
+      #
+      # <tt>document.update_attributes(:title => "Sir")</tt>
+      #
+      # Returns:
+      #
+      # +true+ if validation passed, +false+ if not.
+      def update_attributes(attributes = {})
+        write_attributes(attributes); update
+      end
+
+      # Update the +Document+ attributes in the datbase.
+      #
+      # Example:
+      #
+      # <tt>document.update_attributes(:title => "Sir")</tt>
+      #
+      # Returns:
+      #
+      # +true+ if validation passed, raises an error if not
+      def update_attributes!(attributes = {})
+        write_attributes(attributes)
+        result = update
+        self.class.fail_validate!(self) unless result
+        result
+      end
+
+      # Upsert the document - will perform an insert if the document is new, and
+      # update if not.
+      #
+      # Example:
+      #
+      # <tt>document.upsert</tt>
+      #
+      # Returns:
+      #
+      # A +Boolean+ for updates.
+      def upsert(validate = true)
+        validate = parse_validate(validate)
+        if new_record?
+          insert(validate).errors.any? ? false : true
+        else
+          update(validate)
+        end
+      end
+
+      # Save is aliased so that users familiar with active record can have some
+      # semblance of a familiar API.
+      #
+      # Example:
+      #
+      # <tt>document.save</tt>
+      alias :save :upsert
+
+      protected
+      # Alternative validation params.
+      def parse_validate(validate)
+        if validate.is_a?(Hash) && validate.has_key?(:validate)
+          validate = validate[:validate]
+        end
+        validate
+      end
+    end
+
+    module ClassMethods #:nodoc:
+
+      # 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:
+      #
+      # <tt>Person.create(:title => "Mr")</tt>
+      #
+      # Returns: the +Document+.
+      def create(attributes = {})
+        document = new(attributes); document.insert
+      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:
+      #
+      # <tt>Person.create!(:title => "Mr")</tt>
+      #
+      # Returns: the +Document+.
+      def create!(attributes = {})
+        document = new(attributes)
+        fail_validate!(document) if document.insert.errors.any?
+        document
+      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:
+      #
+      # <tt>Person.delete_all(:conditions => { :title => "Sir" })</tt>
+      # <tt>Person.delete_all</tt>
+      #
+      # Returns: true or raises an error.
+      def delete_all(conditions = {})
+        RemoveAll.new(
+          self,
+          false,
+          conditions[:conditions] || {}
+        ).persist
+      end
+
+      # Delete 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:
+      #
+      # <tt>Person.destroy_all(:conditions => { :title => "Sir" })</tt>
+      # <tt>Person.destroy_all</tt>
+      #
+      # Returns: true or raises an error.
+      def destroy_all(conditions = {})
+        documents = all(conditions)
+        count = documents.count
+        documents.each { |doc| doc.destroy }; count
+      end
+
+      # Raise an error if validation failed.
+      def fail_validate!(document)
+        raise Errors::Validations.new(document.errors)
+      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
+

data/lib/mongoid/state.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module State #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      attr_reader :new_record
+    end
+
+    module InstanceMethods
+      # Returns true if the +Document+ has not been persisted to the database,
+      # false if it has. This is determined by the variable @new_record
+      # and NOT if the object has an id.
+      def new_record?
+        !!@new_record
+      end
+
+      # Sets the new_record boolean - used after document is saved.
+      def new_record=(saved)
+        @new_record = saved
+      end
+
+      # Checks if the document has been saved to the database.
+      def persisted?
+        !new_record?
+      end
+
+      # Returns true if the +Document+ has been succesfully destroyed, and false if it hasn't.
+      # This is determined by the variable @destroyed and NOT by checking the database.
+      def destroyed?
+        @destroyed == true
+      end
+
+      # Sets the destroyed boolean - used after document is destroyed.
+      def destroyed=(destroyed)
+        @destroyed = destroyed && true
+      end
+    end
+  end
+end

data/lib/mongoid/timestamps.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid
+  module Timestamps
+    extend ActiveSupport::Concern
+    included do
+      field :created_at, :type => Time
+      field :updated_at, :type => Time
+      before_save :set_created_at, :set_updated_at
+    end
+
+    module InstanceMethods
+
+      # Update the created_at field on the Document to the current time. This is
+      # only called on create.
+      def set_created_at
+        self.created_at = Time.now.utc if !created_at
+      end
+
+      # Update the updated_at field on the Document to the current time.
+      # This is only called on create and on save.
+      def set_updated_at
+        self.updated_at = Time.now.utc
+      end
+    end
+
+  end
+end

data/lib/mongoid/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  VERSION = "1.9.3"
+end

data/lib/mongoid/versioning.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # Include this module to get automatic versioning of root level documents.
+  # This will add a version field to the +Document+ and a has_many association
+  # with all the versions contained in it.
+  module Versioning
+    extend ActiveSupport::Concern
+    included do
+      field :version, :type => Integer, :default => 1
+      embeds_many :versions, :class_name => self.name
+      before_save :revise
+    end
+    module InstanceMethods
+      # Create a new version of the +Document+. This will load the previous
+      # document from the database and set it as the next version before saving
+      # the current document. It then increments the version number.
+      def revise
+        last_version = self.class.first(:conditions => { :_id => id, :version => version })
+        if last_version
+          self.versions << last_version.clone
+          self.version = version + 1
+          @modifications["versions"] = [ nil, @attributes["versions"] ] if @modifications
+        end
+      end
+    end
+  end
+end

data/lib/mongoid.rb

@@ -0,0 +1,122 @@
+# encoding: utf-8
+# Copyright (c) 2009 Durran Jordan
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+require "delegate"
+require "singleton"
+require "time"
+require "validatable"
+require "active_support/callbacks"
+require "active_support/core_ext"
+require "active_support/inflector"
+require "active_support/time_with_zone"
+require "will_paginate/collection"
+require "mongo"
+require "mongoid/concern"
+require "mongoid/observable"
+require "mongoid/associations"
+require "mongoid/attributes"
+require "mongoid/callbacks"
+require "mongoid/collection"
+require "mongoid/collections"
+require "mongoid/config"
+require "mongoid/contexts"
+require "mongoid/criteria"
+require "mongoid/cursor"
+require "mongoid/deprecation"
+require "mongoid/dirty"
+require "mongoid/extensions"
+require "mongoid/extras"
+require "mongoid/errors"
+require "mongoid/factory"
+require "mongoid/field"
+require "mongoid/fields"
+require "mongoid/finders"
+require "mongoid/identity"
+require "mongoid/indexes"
+require "mongoid/javascript"
+require "mongoid/matchers"
+require "mongoid/memoization"
+require "mongoid/named_scope"
+require "mongoid/paths"
+require "mongoid/persistence"
+require "mongoid/scope"
+require "mongoid/state"
+require "mongoid/timestamps"
+require "mongoid/versioning"
+require "mongoid/components"
+require "mongoid/document"
+
+module Mongoid #:nodoc
+
+  MONGODB_VERSION = "1.4.0"
+
+  class << self
+
+    # Sets the Mongoid configuration options. Best used by passing a block.
+    #
+    # Example:
+    #
+    #   Mongoid.configure do |config|
+    #     name = "mongoid_test"
+    #     host = "localhost"
+    #     config.allow_dynamic_fields = false
+    #     config.master = Mongo::Connection.new.db(name)
+    #     config.slaves = [
+    #       Mongo::Connection.new(host, 27018, :slave_ok => true).db(name),
+    #       Mongo::Connection.new(host, 27019, :slave_ok => true).db(name)
+    #     ]
+    #   end
+    #
+    # Returns:
+    #
+    # The Mongoid +Config+ singleton instance.
+    def configure
+      config = Mongoid::Config.instance
+      block_given? ? yield(config) : config
+    end
+
+    # Easy convenience method for having an alert generated from the
+    # deprecation module.
+    #
+    # Example:
+    #
+    # <tt>Mongoid.deprecate("Method no longer used")</tt>
+    def deprecate(message)
+      Mongoid::Deprecation.instance.alert(message)
+    end
+
+    alias :config :configure
+  end
+
+  # Take all the public instance methods from the Config singleton and allow
+  # them to be accessed through the Mongoid module directly.
+  #
+  # Example:
+  #
+  # <tt>Mongoid.database = Mongo::Connection.new.db("test")</tt>
+  Mongoid::Config.public_instance_methods(false).each do |name|
+    (class << self; self; end).class_eval <<-EOT
+      def #{name}(*args)
+        configure.send("#{name}", *args)
+      end
+    EOT
+  end
+end