mongoid-braxton 2.0.2

data/lib/mongoid/relations/reflections.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # The reflections module provides convenience methods that can retrieve
+    # useful information about associations.
+    module Reflections
+      extend ActiveSupport::Concern
+
+      included do
+
+        delegate \
+          :reflect_on_association,
+          :reflect_on_all_associations, :to => "self.class"
+      end
+
+      module ClassMethods #:nodoc
+
+        # Returns the relation metadata for the supplied name.
+        #
+        # @example Find relation metadata by name.
+        #   Person.reflect_on_association(:addresses)
+        #
+        # @param [ String, Symbol ] name The name of the relation to find.
+        #
+        # @return [ Metadata ] The matching relation metadata.
+        def reflect_on_association(name)
+          relations[name.to_s]
+        end
+
+        # Returns all relation metadata for the supplied macros.
+        #
+        # @example Find multiple relation metadata by macro.
+        #   Person.reflect_on_all_associations(:embeds_many)
+        #
+        # @param [ Array<String, Symbol> ] *macros The relation macros.
+        #
+        # @return [ Array<Metadata> ] The matching relation metadata.
+        def reflect_on_all_associations(*macros)
+          relations.values.select { |meta| macros.include?(meta.macro) }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/safe.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Contains behaviour for determining if Mongoid is in safe mode.
+  module Safe
+
+    # Determine based on configuration if we are persisting in safe mode or
+    # not.
+    #
+    # The query option will always override the global configuration.
+    #
+    # @example Are we in safe mode?
+    #   document.safe_mode?(:safe => true)
+    #
+    # @param [ Hash ] options Persistence options.
+    #
+    # @return [ true, false ] True if in safe mode, false if not.
+    def safe_mode?(options)
+      safe = options[:safe]
+      safe.nil? ? Mongoid.persist_in_safe_mode : safe
+    end
+  end
+end

data/lib/mongoid/safety.rb

@@ -0,0 +1,207 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # The +Safety+ module is used to provide a DSL to execute database operations
+  # in safe mode on a per query basis, either from the +Document+ class level
+  # or instance level.
+  module Safety
+    extend ActiveSupport::Concern
+
+    # Execute the following class-level persistence operation in safe mode.
+    #
+    # @example Upsert in safe mode.
+    #   person.safely.upsert
+    #
+    # @example Destroy in safe mode with w and fsync options.
+    #   person.safely(:w => 2, :fsync => true).destroy
+    #
+    # @param [ Hash ] options The safe mode options.
+    #
+    # @option options [ Integer ] :w The number of nodes to write to.
+    # @option options [ Integer ] :wtimeout Time to wait for return from all
+    #   nodes.
+    # @option options [ true, false ] :fsync Should a fsync occur.
+    #
+    # @return [ Proxy ] The safety proxy.
+    def safely(safety = true)
+      Proxy.new(self, safety)
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Execute the following class-level persistence operation in safe mode.
+      #
+      # @example Create in safe mode.
+      #   Person.safely.create(:name => "John")
+      #
+      # @example Delete all in safe mode with options.
+      #   Person.safely(:w => 2, :fsync => true).delete_all
+      #
+      # @param [ Hash ] options The safe mode options.
+      #
+      # @option options [ Integer ] :w The number of nodes to write to.
+      # @option options [ Integer ] :wtimeout Time to wait for return from all
+      #   nodes.
+      # @option options [ true, false ] :fsync Should a fsync occur.
+      #
+      # @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
+      end
+    end
+  end
+end

data/lib/mongoid/scope.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # This module handles behaviour for defining scopes on classes.
+  class Scope
+    attr_reader :conditions, :extensions
+
+    # Create the new +Scope+. If a block is passed in, this Scope will store
+    # the block for future calls to #extend.
+    #
+    # @example Create a new scope.
+    #   Scope.new(:title => "Sir")
+    #
+    # @param [ Hash ] conditions The scoping limitations.
+    def initialize(conditions = {}, &block)
+      @conditions = conditions
+      @extensions = Module.new(&block) if block_given?
+    end
+
+    # Extend a supplied criteria.
+    #
+    # @example Extend the criteria.
+    #   scope.extend(criteria)
+    #
+    # @param [ Criteria } criteria A mongoid criteria to extend.
+    #
+    # @return [ Criteria ] The new criteria object.
+    def extend(criteria)
+      extensions ? criteria.extend(extensions) : criteria
+    end
+  end
+end

data/lib/mongoid/serialization.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+
+  # This module provides the extra behaviour for including relations in JSON
+  # and XML serialization.
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serialization
+
+    # Gets the document as a serializable hash, used by ActiveModel's JSON and
+    # XML serializers. This override is just to be able to pass the :include
+    # and :except options to get associations in the hash.
+    #
+    # @example Get the serializable hash.
+    #   document.serializable_hash
+    #
+    # @example Get the serializable hash with options.
+    #   document.serializable_hash(:include => :addresses)
+    #
+    # @param [ Hash ] options The options to pass.
+    #
+    # @option options [ Symbol ] :include What relations to include
+    # @option options [ Symbol ] :only Limit the fields to only these.
+    # @option options [ Symbol ] :except Dont include these fields.
+    #
+    # @return [ Hash ] The document, ready to be serialized.
+    #
+    # @since 2.0.0.rc.6
+    def serializable_hash(options = nil)
+      options ||= {}
+      super(options).tap do |attrs|
+        serialize_relations(attrs, options) if options[:include]
+      end
+    end
+
+    private
+
+    # For each of the provided include options, get the relation needed and
+    # provide it in the hash.
+    #
+    # @example Serialize the included relations.
+    #   document.serialize_relations({}, :include => :addresses)
+    #
+    # @param [ Hash ] attributes The attributes to serialize.
+    # @param [ Hash ] options The serialization options.
+    #
+    # @option options [ Symbol ] :include What relations to include
+    # @option options [ Symbol ] :only Limit the fields to only these.
+    # @option options [ Symbol ] :except Dont include these fields.
+    #
+    # @since 2.0.0.rc.6
+    def serialize_relations(attributes = {}, options = {})
+      inclusions = options[:include]
+      relation_names(inclusions).each do |name|
+        metadata = relations[name.to_s]
+        relation = send(metadata.name, false, :eager => true)
+        if relation
+          attributes[metadata.name.to_s] =
+            relation.serializable_hash(relation_options(inclusions, options, name))
+        end
+      end
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the names.
+    #
+    # @example Get the relation names.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash, Symbol, Array<Symbol ] inclusions The inclusions.
+    #
+    # @return [ Array<Symbol> ] The names of the included relations.
+    #
+    # @since 2.0.0.rc.6
+    def relation_names(inclusions)
+      inclusions.is_a?(Hash) ? inclusions.keys : Array.wrap(inclusions)
+    end
+
+    # Since the inclusions can be a hash, symbol, or array of symbols, this is
+    # provided as a convenience to parse out the options.
+    #
+    # @example Get the relation options.
+    #   document.relation_names(:include => [ :addresses ])
+    #
+    # @param [ Hash, Symbol, Array<Symbol ] inclusions The inclusions.
+    # @param [ Symbol ] name The name of the relation.
+    #
+    # @return [ Hash ] The options for the relation.
+    #
+    # @since 2.0.0.rc.6
+    def relation_options(inclusions, options, name)
+      if inclusions.is_a?(Hash)
+        inclusions[name]
+      else
+        { :except => options[:except], :only => options[:only] }
+      end
+    end
+  end
+end

data/lib/mongoid/sharding.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # This module contains behaviour for adding shard key fields to updates.
+  module Sharding
+    extend ActiveSupport::Concern
+
+    included do
+      cattr_accessor :shard_key_fields
+      self.shard_key_fields = []
+
+      delegate :shard_key_fields, :to => "self.class"
+    end
+
+    # Get the document selector with the defined shard keys.
+    #
+    # @example Get the selector for the shard keys.
+    #   person.shard_key_selector
+    #
+    # @return [ Hash ] The shard key selector.
+    #
+    # @since 2.0.0
+    def shard_key_selector
+      {}.tap do |selector|
+        shard_key_fields.each do |field|
+          selector[field.to_s] = send(field)
+        end
+      end
+    end
+
+    module ClassMethods #:nodoc
+
+      # Specifies a shard key with the field(s) specified.
+      #
+      # @example Specify the shard key.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :first_name, :type => String
+      #     field :last_name, :type => String
+      #
+      #     shard_key :first_name, :last_name
+      #   end
+      #
+      # @since 2.0.0
+      def shard_key(*names)
+        self.shard_key_fields = names
+      end
+    end
+  end
+end