mongoid-braxton 2.0.2

data/lib/mongoid/criterion/selector.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+
+    # The selector is a hash-like object that has special behaviour for merging
+    # mongoid criteria selectors.
+    class Selector < Hash
+
+      attr_reader :fields, :klass
+
+      # Create the new selector.
+      #
+      # @example Create the selector.
+      #   Selector.new(Person)
+      #
+      # @param [ Class ] klass The class the selector is for.
+      #
+      # @since 1.0.0
+      def initialize(klass)
+        @fields, @klass = klass.fields.except("_id", "_type"), klass
+      end
+
+      # Set the value for the supplied key, attempting to typecast the value.
+      #
+      # @example Set the value for the key.
+      #   selector["$ne"] = { :name => "Zorg" }
+      #
+      # @param [ String, Symbol ] key The hash key.
+      # @param [ Object ] value The value to set.
+      #
+      # @since 2.0.0
+      def []=(key, value)
+        super(key, try_to_typecast(key, value))
+      end
+
+      # Merge the selector with another hash.
+      #
+      # @example Merge the objects.
+      #   selector.merge!({ :key => "value" })
+      #
+      # @param [ Hash, Selector ] other The object to merge with.
+      #
+      # @return [ Selector ] The merged selector.
+      #
+      # @since 1.0.0
+      def merge!(other)
+        tap do |selector|
+          other.each_pair do |key, value|
+            selector[key] = value
+          end
+        end
+      end
+      alias :update :merge!
+
+      if RUBY_VERSION < '1.9'
+
+        # Generate pretty inspection for old ruby versions.
+        #
+        # @example Inspect the selector.
+        #   selector.inspect
+        #
+        # @return [ String ] The inspected selector.
+        def inspect
+          ret = self.keys.inject([]) do |ret, key|
+            ret << "#{key.inspect}=>#{self[key].inspect}"
+          end
+          "{#{ret.sort.join(', ')}}"
+        end
+      end
+
+      private
+
+      # If the key is defined as a field, then attempt to typecast it.
+      #
+      # @example Try to cast.
+      #   selector.try_to_typecast(:id, 1)
+      #
+      # @param [ String, Symbol ] key The field name.
+      # @param [ Object ] value The value.
+      #
+      # @return [ Object ] The typecasted value.
+      #
+      # @since 1.0.0
+      def try_to_typecast(key, value)
+        access = key.to_s
+        return value unless fields.has_key?(access)
+        field = fields[access]
+        typecast_value_for(field, value)
+      end
+
+      # Get the typecast value for the defined field.
+      #
+      # @example Get the typecast value.
+      #   selector.typecast_value_for(:name, "Corbin")
+      #
+      # @param [ Field ] field The defined field.
+      # @param [ Object ] value The value to cast.
+      #
+      # @return [ Object ] The cast value.
+      #
+      # @since 1.0.0
+      def typecast_value_for(field, value)
+        return field.set(value) if field.type === value
+        case value
+        when Hash
+          value = value.dup
+          value.each_pair do |k, v|
+            value[k] = typecast_hash_value(field, k, v)
+          end
+        when Array
+          value.map { |v| typecast_value_for(field, v) }
+        when Regexp
+          value
+        else
+          field.type == Array ? value.class.set(value) : field.set(value)
+        end
+      end
+
+      # Typecast the value for booleans and integers in hashes.
+      #
+      # @example Typecast the hash values.
+      #   selector.typecast_hash_value(field, "$exists", "true")
+      #
+      # @param [ Field ] field The defined field.
+      # @param [ String ] key The modifier key.
+      # @param [ Object ] value The value to cast.
+      #
+      # @return [ Object ] The cast value.
+      #
+      # @since 1.0.0
+      def typecast_hash_value(field, key, value)
+        case key
+        when "$exists"
+          Boolean.set(value)
+        when "$size"
+          Integer.set(value)
+        else
+          typecast_value_for(field, value)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/criterion/unconvertable.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+
+    # Wrapper class for strings that should not be converted into
+    # BSON::ObjectIds.
+    class Unconvertable < String
+
+      # Initialize just like a normal string, and quack like it to.
+      #
+      # @example Create the new Unconvertable.
+      #   Unconvertable.new("testing")
+      #
+      # @param [ String ] value The string.
+      #
+      # @since 2.0.2
+      def initialize(value); super; end
+    end
+  end
+end

data/lib/mongoid/cursor.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  class Cursor
+    include Mongoid::Collections::Retry
+    include Enumerable
+    # Operations on the Mongo::Cursor object that will not get overriden by the
+    # Mongoid::Cursor are defined here.
+    OPERATIONS = [
+      :close,
+      :closed?,
+      :count,
+      :explain,
+      :fields,
+      :full_collection_name,
+      :hint,
+      :limit,
+      :order,
+      :query_options_hash,
+      :query_opts,
+      :selector,
+      :skip,
+      :snapshot,
+      :sort,
+      :timeout
+    ]
+
+    attr_reader :collection
+
+    # The operations above will all delegate to the proxied Mongo::Cursor.
+    #
+    # Example:
+    #
+    # <tt>cursor.close</tt>
+    OPERATIONS.each do |name|
+      define_method(name) do |*args|
+        retry_on_connection_failure do
+          @cursor.send(name, *args)
+        end
+      end
+    end
+
+    # Iterate over each document in the cursor and yield to it.
+    #
+    # Example:
+    #
+    # <tt>cursor.each { |doc| p doc.title }</tt>
+    def each
+      @cursor.each do |document|
+        yield Mongoid::Factory.from_db(@klass, document)
+      end
+    end
+
+    # Create the new +Mongoid::Cursor+.
+    #
+    # Options:
+    #
+    # collection: The Mongoid::Collection instance.
+    # cursor: The Mongo::Cursor to be proxied.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Cursor.new(Person, cursor)</tt>
+    def initialize(klass, collection, cursor)
+      @klass, @collection, @cursor = klass, collection, cursor
+    end
+
+    # Return the next document in the cursor. Will instantiate a new Mongoid
+    # document with the attributes.
+    #
+    # Example:
+    #
+    # <tt>cursor.next_document</tt>
+    def next_document
+      Mongoid::Factory.from_db(@klass, @cursor.next_document)
+    end
+
+    # Returns an array of all the documents in the cursor.
+    #
+    # Example:
+    #
+    # <tt>cursor.to_a</tt>
+    def to_a
+      @cursor.to_a.collect { |attrs| Mongoid::Factory.from_db(@klass, attrs) }
+    end
+  end
+end

data/lib/mongoid/default_scope.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module handles functionality for creating default scopes.
+  module DefaultScope
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :default_scoping
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Creates a default_scope for the +Document+, similar to ActiveRecord's
+      # default_scope. +DefaultScopes+ are proxied +Criteria+ objects that are
+      # applied by default to all queries for the class.
+      #
+      # @example Create a default scope.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :active, :type => Boolean
+      #     field :count, :type => Integer
+      #
+      #     default_scope :where => { :active => true }
+      #   end
+      #
+      # @param [ Hash ] conditions The conditions to create with.
+      #
+      # @since 2.0.0.rc.1
+      def default_scope(conditions = {})
+        self.default_scoping = Scope.new(conditions).conditions.scoped
+      end
+    end
+  end
+end

data/lib/mongoid/dirty.rb

@@ -0,0 +1,253 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Dirty #:nodoc:
+    extend ActiveSupport::Concern
+
+    # Gets the changes for a specific field.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.attribute_change("title") # [ "Sir", "Madam" ]
+    #
+    # Returns:
+    #
+    # An +Array+ containing the old and new values.
+    def attribute_change(name)
+      modifications[name]
+    end
+
+    # Determines if a specific field has chaged.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.attribute_changed?("title") # true
+    #
+    # Returns:
+    #
+    # +true+ if changed, +false+ if not.
+    def attribute_changed?(name)
+      modifications.include?(name)
+    end
+
+    # Gets the old value for a specific field.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.attribute_was("title") # "Sir"
+    #
+    # Returns:
+    #
+    # The old field value.
+    def attribute_was(name)
+      change = modifications[name]
+      change ? change[0] : attributes[name]
+    end
+
+    # Gets the names of all the fields that have changed in the document.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.changed # returns [ "title" ]
+    #
+    # Returns:
+    #
+    # An +Array+ of changed field names.
+    def changed
+      modifications.keys
+    end
+
+    # Alerts to whether the document has been modified or not.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.changed? # returns true
+    #
+    # Returns:
+    #
+    # +true+ if changed, +false+ if not.
+    def changed?
+      !modifications.empty?
+    end
+
+    # Gets all the modifications that have happened to the object as a +Hash+
+    # with the keys being the names of the fields, and the values being an
+    # +Array+ with the old value and new value.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.changes # returns { "title" => [ "Sir", "Madam" ] }
+    #
+    # Returns:
+    #
+    # A +Hash+ of changes.
+    def changes
+      modifications
+    end
+
+    # Call this method after save, so the changes can be properly switched.
+    #
+    # Example:
+    #
+    # <tt>person.move_changes</tt>
+    def move_changes
+      @validated = false
+      @previous_modifications = modifications.dup
+      @modifications = {}
+    end
+
+    # Gets all the new values for each of the changed fields, to be passed to
+    # a MongoDB $set modifier.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.setters # returns { "title" => "Madam" }
+    #
+    # Returns:
+    #
+    # A +Hash+ of new values.
+    def setters
+      modifications.inject({}) do |sets, (field, changes)|
+        key = embedded? ? "#{_position}.#{field}" : field
+        sets[key] = changes[1]; sets
+      end
+    end
+
+    # Gets all the modifications that have happened to the object before the
+    # object was saved.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.save!
+    #   person.previous_changes # returns { "title" => [ "Sir", "Madam" ] }
+    #
+    # Returns:
+    #
+    # A +Hash+ of changes before save.
+    def previous_changes
+      @previous_modifications
+    end
+
+    # Resets a changed field back to its old value.
+    #
+    # Example:
+    #
+    #   person = Person.new(:title => "Sir")
+    #   person.title = "Madam"
+    #   person.reset_attribute!("title")
+    #   person.title # "Sir"
+    #
+    # Returns:
+    #
+    # The old field value.
+    def reset_attribute!(name)
+      value = attribute_was(name)
+      value ? attributes[name] = value : attributes.delete(name)
+      modifications.delete(name)
+    end
+
+    # Sets up the modifications hash. This occurs just after the document is
+    # instantiated.
+    #
+    # Example:
+    #
+    # <tt>document.setup_notifications</tt>
+    def setup_modifications
+      @accessed ||= {}
+      @modifications ||= {}
+      @previous_modifications ||= {}
+    end
+
+    # Reset all modifications for the document. This will wipe all the marked
+    # changes, but not reset the values.
+    #
+    # Example:
+    #
+    # <tt>document.reset_modifications</tt>
+    def reset_modifications
+      @accessed = {}
+      @modifications = {}
+    end
+
+    protected
+
+    # Audit the original value for a field that can be modified in place.
+    #
+    # Example:
+    #
+    # <tt>person.accessed("aliases", [ "007" ])</tt>
+    def accessed(name, value)
+      return value unless value.is_a?(Enumerable)
+      @accessed ||= {}
+      @accessed[name] = value.dup unless @accessed.has_key?(name)
+      value
+    end
+
+    # Get all normal modifications plus in place potential changes.
+    #
+    # Example:
+    #
+    # <tt>person.modifications</tt>
+    #
+    # Returns:
+    #
+    # All changes to the document.
+    def modifications
+      reset_modifications unless @modifications && @accessed
+      @accessed.each_pair do |field, value|
+        current = attributes[field]
+        @modifications[field] = [ value, current ] if current != value
+      end
+      @accessed.clear
+      @modifications
+    end
+
+    # Audit the change of a field's value.
+    #
+    # Example:
+    #
+    # <tt>person.modify("name", "Jack", "John")</tt>
+    def modify(name, old_value, new_value)
+      attributes[name] = new_value
+      if @modifications && (old_value != new_value)
+        original = @modifications[name].first if @modifications[name]
+        @modifications[name] = [ (original || old_value), new_value ]
+      end
+    end
+
+    module ClassMethods #:nodoc:
+      # Add the dynamic dirty methods. These are custom methods defined on a
+      # field by field basis that wrap the dirty attribute methods.
+      #
+      # Example:
+      #
+      #   person = Person.new(:title => "Sir")
+      #   person.title = "Madam"
+      #   person.title_change # [ "Sir", "Madam" ]
+      #   person.title_changed? # true
+      #   person.title_was # "Sir"
+      #   person.reset_title!
+      def add_dirty_methods(name)
+        define_method("#{name}_change") { attribute_change(name) } unless instance_methods.include?("#{name}_change") || instance_methods.include?(:"#{name}_change")
+        define_method("#{name}_changed?") { attribute_changed?(name) } unless instance_methods.include?("#{name}_changed?") || instance_methods.include?(:"#{name}_changed?")
+        define_method("#{name}_was") { attribute_was(name) } unless instance_methods.include?("#{name}_was") || instance_methods.include?(:"#{name}_was")
+        define_method("reset_#{name}!") { reset_attribute!(name) } unless instance_methods.include?("reset_#{name}!") || instance_methods.include?(:"reset_#{name}!")
+      end
+    end
+  end
+end