mongoid 1.1.4 → 1.2.0

data/HISTORY

@@ -1,4 +1,72 @@
-=== 1.0.7
+=== 1.2.0
+- Fixed composite key generation not to replace all
+  special chars with dashes.
+
+- Memory optimizations, now wrapping the mongo cursor.
+
+- Fixed memoization on has_many_related assocations.
+
+- Fixed pagination on embedded associations
+
+- Fixed after_update callback not getting fired.
+
+- When a connection failure occurs, Mongoid tried to
+  retry the operation up to a configurable time.
+
+- Mongoid now supports a configuration with a master
+  and multiple read slaves. It will direct all writes
+  to the master and all reads to the slaves. In the case
+  of a write, subsequent reads will be directed to the
+  master up to configurable number to try and counter
+  the 2 second slave sync delay.
+
+- Fixed issue with criteria exclusion queries with ids.
+
+- Mongoid only executes a count when explicitly paginating.
+
+- Fixed Criteria offset to be a getter or setter
+
+- Added indexes to foreign keys on belongs_to_related
+  associations.
+
+- General code refactorings/cleanup
+
+=== 1.1.4
+- Refactorings in preparation for next feature push.
+
+- Associations may now have anonymous extensions.
+
+- Ruby 1.9 compatibility updates. (brainopia)
+
+- Document.to_json accepts options. (jsmestad)
+
+=== 1.1.3
+- Nil can be passed into methods that set attributes.
+
+- Mongoid.config can now take a block.
+
+- Allow named_scopes and criteria class methods on
+  has_many_related if related is a Mongoid document.
+
+- Document.find can now take an array of ids.
+
+=== 1.1.2
+- Fixing issues with updates to parents.
+
+=== 1.1.1
+- Document.create raises validations error, not no
+  method error on self.errors (Rick Frankel)
+
+- Support default values that respond_to?(:call)
+  (procs/lambda) (ahoward)
+
+- Added Mongoid.persist_in_safe_mode global config
+  option.
+
+- Minor optimization: don't evaluate default procs
+  if it's not needed (brainopia)
+
+=== 1.1.0
 - Nil attributes no longer persist nil values to the
   database - the field will just not exist.
 

data/Rakefile

@@ -15,7 +15,7 @@ begin
     gem.add_dependency("activesupport", "<= 2.3.5")
     gem.add_dependency("mongo", ">= 0.18.2")
     gem.add_dependency("durran-validatable", ">= 2.0.1")
-    gem.add_dependency("leshill-will_paginate", ">= 2.3.11")
+    gem.add_dependency("will_paginate", ">= 2.3.11")
 
     gem.add_development_dependency("rspec", ">= 1.2.9")
     gem.add_development_dependency("mocha", ">= 0.9.8")

data/VERSION

@@ -1 +1 @@
-1.1.4
+1.2.0

data/lib/mongoid.rb

@@ -24,7 +24,7 @@ require "rubygems"
 gem "activesupport", ">= 2.2.2", "<3.0.pre"
 gem "mongo", ">= 0.18.2"
 gem "durran-validatable", ">= 2.0.1"
-gem "leshill-will_paginate", ">= 2.3.11"
+gem "will_paginate", ">= 2.3.11"
 
 require "delegate"
 require "observer"
@@ -41,12 +41,15 @@ require "mongoid/associations"
 require "mongoid/associations/options"
 require "mongoid/attributes"
 require "mongoid/callbacks"
+require "mongoid/collection"
 require "mongoid/commands"
 require "mongoid/config"
 require "mongoid/contexts"
 require "mongoid/criteria"
+require "mongoid/cursor"
 require "mongoid/extensions"
 require "mongoid/errors"
+require "mongoid/factory"
 require "mongoid/field"
 require "mongoid/fields"
 require "mongoid/finders"
@@ -65,20 +68,43 @@ module Mongoid #:nodoc
 
   class << self
 
-    delegate \
-      :allow_dynamic_fields,
-      :allow_dynamic_fields=,
-      :database,
-      :database=,
-      :persist_in_safe_mode,
-      :persist_in_safe_mode=,
-      :raise_not_found_error,
-      :raise_not_found_error=, :to => :config
-
-    def config
-      yield Config.instance if block_given?; Config.instance
+    # 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 = Config.instance
+      block_given? ? yield(config) : config
     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>
+  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

data/lib/mongoid/associations.rb

@@ -88,6 +88,7 @@ module Mongoid # :nodoc:
       #
       def belongs_to_related(name, options = {}, &block)
         field "#{name.to_s}_id"
+        index "#{name.to_s}_id" unless self.embedded
         add_association(
           Associations::BelongsToRelated,
           Associations::Options.new(

data/lib/mongoid/associations/has_many.rb

@@ -97,9 +97,9 @@ module Mongoid #:nodoc:
       # If the method exists on the array, use the default proxy behavior.
       def method_missing(name, *args, &block)
         unless @target.respond_to?(name)
-          criteria = @klass.send(name, *args)
-          criteria.documents = @target
-          return criteria
+          object = @klass.send(name, *args)
+          object.documents = @target
+          return object
         end
         super
       end
@@ -120,6 +120,22 @@ module Mongoid #:nodoc:
         end
       end
 
+      # Paginate the association. Will create a new criteria, set the documents
+      # on it and execute in an enumerable context.
+      #
+      # Options:
+      #
+      # options: A +Hash+ of pagination options.
+      #
+      # Returns:
+      #
+      # A +WillPaginate::Collection+.
+      def paginate(options)
+        criteria = Mongoid::Criteria.translate(@klass, options)
+        criteria.documents = @target
+        criteria.paginate
+      end
+
       protected
       # Initializes each of the attributes in the hash.
       def initialize_each(attributes)

data/lib/mongoid/attributes.rb

@@ -40,7 +40,7 @@ module Mongoid #:nodoc:
       # put into the document's attributes.
       def process(attrs = nil)
         (attrs || {}).each_pair do |key, value|
-          if Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
+          if set_allowed?(key)
             @attributes[key.to_s] = value
           else
             send("#{key}=", value) if value
@@ -131,6 +131,11 @@ module Mongoid #:nodoc:
       end
 
       protected
+      # Return true is dynamic field setting is enabled.
+      def set_allowed?(key)
+        Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
+      end
+
       # Used when supplying a :reject_if block as an option to
       # accepts_nested_attributes_for
       def reject(attributes, options)

data/lib/mongoid/collection.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+require "mongoid/collections/operations"
+require "mongoid/collections/cyclic_iterator"
+require "mongoid/collections/mimic"
+require "mongoid/collections/master"
+require "mongoid/collections/slaves"
+
+module Mongoid #:nodoc
+  class Collection
+    include Collections::Mimic
+    attr_reader :counter, :name
+
+    # All write operations should delegate to the master connection. These
+    # operations mimic the methods on a Mongo:Collection.
+    #
+    # Example:
+    #
+    # <tt>collection.save({ :name => "Al" })</tt>
+    proxy(:master, Collections::Operations::WRITE)
+
+    # All read operations should be intelligently directed to either the master
+    # or the slave, depending on where the read counter is and what it's
+    # maximum was configured at.
+    #
+    # Example:
+    #
+    # <tt>collection.find({ :name => "Al" })</tt>
+    proxy(:directed, (Collections::Operations::READ - [:find]))
+
+    # Determines where to send the next read query. If the slaves are not
+    # defined then send to master. If the read counter is under the configured
+    # maximum then return the master. In any other case return the slaves.
+    #
+    # Example:
+    #
+    # <tt>collection.directed</tt>
+    #
+    # Return:
+    #
+    # Either a +Master+ or +Slaves+ collection.
+    def directed
+      if under_max_counter? || slaves.empty?
+        @counter = @counter + 1
+        master
+      else
+        @counter = 0
+        slaves
+      end
+    end
+
+    # Find documents from the database given a selector and options.
+    #
+    # Options:
+    #
+    # selector: A +Hash+ selector that is the query.
+    # options: The options to pass to the db.
+    #
+    # Example:
+    #
+    # <tt>collection.find({ :test => "value" })</tt>
+    def find(selector = {}, options = {})
+      cursor = Mongoid::Cursor.new(self, directed.find(selector, options))
+      if block_given?
+        yield cursor; cursor.close
+      else
+        cursor
+      end
+    end
+
+    # Initialize a new Mongoid::Collection, setting up the master, slave, and
+    # name attributes. Masters will be used for writes, slaves for reads.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Collection.new(masters, slaves, "test")</tt>
+    def initialize(name)
+      @name, @counter = name, 0
+    end
+
+    # Return the object responsible for reading documents from the database.
+    # This is usually the slave databases, but in their absence the master will
+    # handle the task.
+    #
+    # Example:
+    #
+    # <tt>collection.reader</tt>
+    def slaves
+      @slaves ||= Collections::Slaves.new(Mongoid.slaves, @name)
+    end
+
+    # Return the object responsible for writes to the database. This will
+    # always return a collection associated with the Master DB.
+    #
+    # Example:
+    #
+    # <tt>collection.writer</tt>
+    def master
+      @master ||= Collections::Master.new(Mongoid.master, @name)
+    end
+
+    protected
+    def under_max_counter?
+      @counter < Mongoid.max_successive_reads
+    end
+  end
+end

data/lib/mongoid/collections/cyclic_iterator.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class CyclicIterator
+
+      attr_reader :counter
+
+      # Performs iteration over an array, if the array gets to the end then loop
+      # back to the first.
+      #
+      # Example:
+      #
+      # <tt>CyclicIterator.new([ first, second ])</tt>
+      def initialize(array)
+        @array, @counter = array, -1
+      end
+
+      # Get the next element in the array. If the element is the last in the
+      # array then return the first.
+      #
+      # Example:
+      #
+      # <tt>iterator.next</tt>
+      #
+      # Returns:
+      #
+      # The next element in the array.
+      def next
+        (@counter == @array.size - 1) ? @counter = 0 : @counter = @counter + 1
+        @array[@counter]
+      end
+    end
+  end
+end

data/lib/mongoid/collections/master.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    class Master
+      include Mimic
+
+      attr_reader :collection
+
+      # All read and write operations should delegate to the master connection.
+      # These operations mimic the methods on a Mongo:Collection.
+      #
+      # Example:
+      #
+      # <tt>collection.save({ :name => "Al" })</tt>
+      proxy(:collection, Operations::ALL)
+
+      # Create the new database writer. Will create a collection from the
+      # master database.
+      #
+      # Example:
+      #
+      # <tt>Master.new(master, "mongoid_people")</tt>
+      def initialize(master, name)
+        @collection = master.collection(name)
+      end
+    end
+  end
+end

data/lib/mongoid/collections/mimic.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Collections #:nodoc:
+    module Mimic #:nodoc:
+      def self.included(base)
+        base.class_eval do
+          include InstanceMethods
+          extend ClassMethods
+        end
+      end
+
+      module InstanceMethods #:nodoc:
+        # Retry the supplied operation until the reconnect time has expired,
+        # defined in the mongoid Config module.
+        #
+        # Example:
+        #
+        # <tt>master.attempt(operation)</tt>
+        def attempt(operation, start)
+          begin
+            elapsed = (Time.now - start)
+            operation.call
+          rescue Mongo::ConnectionFailure => error
+            (elapsed < Mongoid.reconnect_time) ? retry : (raise error)
+          end
+        end
+      end
+
+      module ClassMethods #:nodoc:
+        # Proxy all the supplied operations to the internal collection or target.
+        #
+        # Example:
+        #
+        # <tt>proxy Operations::ALL, :collection</tt>
+        def proxy(target, operations)
+          operations.each do |name|
+            define_method(name) do |*args|
+              operation = lambda { send(target).send(name, *args) }
+              attempt(operation, Time.now)
+            end
+          end
+        end
+      end
+    end
+  end
+end