stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/extras.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extras #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      class_attribute :cached, :enslaved
+      self.cached = false
+      self.enslaved = false
+      delegate :cached?, :enslaved?, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc
+      # Sets caching on for this class. This class level configuration will
+      # default all queries to cache the results of the first iteration over
+      # the cursor into an internal array. This should only be used for queries
+      # that return a small number of results or have small documents, as after
+      # the first iteration the entire results will be stored in memory.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     cache
+      #   end
+      def cache
+        self.cached = true
+      end
+
+      # Determines if the class is cached or not.
+      #
+      # Returns:
+      #
+      # True if cached, false if not.
+      def cached?
+        !!self.cached
+      end
+
+      # Set whether or not this documents read operations should delegate to
+      # the slave database by default.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     enslave
+      #   end
+      def enslave
+        self.enslaved = true
+      end
+
+      # Determines if the class is enslaved or not.
+      #
+      # Returns:
+      #
+      # True if enslaved, false if not.
+      def enslaved?
+        !!self.enslaved
+      end
+    end
+  end
+end

data/lib/mongoid/factory.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Factory #:nodoc:
+    # Builds a new +Document+ from the supplied attributes.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Factory.build(Person, {})</tt>
+    #
+    # Options:
+    #
+    # klass: The class to instantiate from if _type is not present.
+    # attributes: The +Document+ attributes.
+    def self.build(klass, attributes)
+      attrs = {}.merge(attributes)
+      type = attrs["_type"]
+      type ? type.constantize.instantiate(attrs) : klass.instantiate(attrs)
+    end
+  end
+end

data/lib/mongoid/field.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Field
+    attr_reader :copyable, :klass, :label, :name, :options, :type
+
+    # Get the default value for the field.
+    #
+    # Returns:
+    #
+    # The typecast default value.
+    def default
+      copy.respond_to?(:call) ? copy : set(copy)
+    end
+
+    # Create the new field with a name and optional additional options. Valid
+    # options are :default
+    #
+    # Options:
+    #
+    # name: The name of the field as a +Symbol+.
+    # options: A +Hash+ of options for the field.
+    #
+    # Example:
+    #
+    # <tt>Field.new(:score, :default => 0)</tt>
+    def initialize(name, options = {})
+      check_name!(name)
+      @type = options[:type] || Object
+      @name, @default = name, options[:default]
+      @copyable = (@default.is_a?(Array) || @default.is_a?(Hash))
+      @label = options[:label]
+      @options = options
+      check_default!
+    end
+
+    # Used for setting an object in the attributes hash.
+    #
+    # If nil is provided the default will get returned if it exists.
+    #
+    # If the field is an identity field, ie an id, it performs the necessary
+    # cast.
+    #
+    # Example:
+    #
+    # <tt>field.set("New Value")</tt>
+    #
+    # Returns:
+    #
+    # The new value.
+    def set(object)
+      unless options[:identity]
+        type.set(object)
+      else
+        if object.blank?
+          type.set(object)
+        else
+          options[:metadata].constraint.convert(object)
+        end
+      end
+    end
+
+    # Used for retrieving the object out of the attributes hash.
+    #
+    # Example:
+    #
+    # <tt>field.get("Value")</tt>
+    #
+    # Returns:
+    #
+    # The converted value.
+    def get(object)
+      type.get(object)
+    end
+
+    protected
+    # Slightly faster default check.
+    def copy
+      copyable ? @default.dup : @default
+    end
+
+    # Check if the name is valid.
+    def check_name!(name)
+      if Mongoid.destructive_fields.include?(name.to_s)
+        raise Mongoid::Errors::InvalidField.new(name)
+      end
+    end
+
+    def check_default!
+      return if @default.is_a?(Proc)
+      if !@default.nil? && !@default.is_a?(type)
+        raise Mongoid::Errors::InvalidType.new(type, @default)
+      end
+    end
+  end
+end

data/lib/mongoid/fields.rb

@@ -0,0 +1,138 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # This module defines behaviour for fields.
+  module Fields
+    extend ActiveSupport::Concern
+
+    included do
+      # Set up the class attributes that must be available to all subclasses.
+      # These include defaults, fields
+      delegate :defaults, :fields, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc
+
+      # Defines all the fields that are accessable on the Document
+      # For each field that is defined, a getter and setter will be
+      # added as an instance method to the Document.
+      #
+      # @example Define a field.
+      #   field :score, :type => Integer, :default => 0
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The options to pass to the field.
+      #
+      # @option options [ Class ] :type The type of the field.
+      # @option options [ String ] :label The label for the field.
+      # @option options [ Object, Proc ] :default The field's default
+      def field(name, options = {})
+        access = name.to_s
+        set_field(access, options)
+        attr_protected name if options[:accessible] == false
+      end
+
+      # Return the fields for this class.
+      #
+      # @example Get the fields.
+      #   Person.fields
+      #
+      # @return [ Hash ] The fields for this document.
+      #
+      # @since 2.0.0.rc.6
+      def fields
+        @fields ||= {}
+      end
+
+      # Set the fields for the class.
+      #
+      # @example Set the fields.
+      #   Person.fields = fields
+      #
+      # @param [ Hash ] fields The hash of fields to set.
+      #
+      # @since 2.0.0.rc.6
+      def fields=(fields)
+        @fields = fields
+      end
+
+      # Returns the default values for the fields on the document.
+      #
+      # @example Get the defaults.
+      #   Person.defaults
+      #
+      # @return [ Hash ] The field defaults.
+      def defaults
+        fields.inject({}) do |defs, (field_name,field)|
+          next(defs) if field.default.nil?
+          defs[field_name.to_s] = field.default
+          defs
+        end
+      end
+
+      # When inheriting, we want to copy the fields from the parent class and
+      # set the on the child to start, mimicing the behaviour of the old
+      # class_inheritable_accessor that was deprecated in Rails edge.
+      #
+      # @example Inherit from this class.
+      #   Person.inherited(Doctor)
+      #
+      # @param [ Class ] subclass The inheriting class.
+      #
+      # @since 2.0.0.rc.6
+      def inherited(subclass)
+        subclass.fields = fields.dup
+      end
+
+      protected
+
+      # Define a field attribute for the +Document+.
+      #
+      # @example Set the field.
+      #   Person.set_field(:name, :default => "Test")
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The hash of options.
+      def set_field(name, options = {})
+        meth = options.delete(:as) || name
+        fields[name] = Field.new(name, options)
+        create_accessors(name, meth, options)
+        add_dirty_methods(name)
+      end
+
+      # Create the field accessors.
+      #
+      # @example Generate the accessors.
+      #   Person.create_accessors(:name, "name")
+      #   person.name #=> returns the field
+      #   person.name = "" #=> sets the field
+      #   person.name? #=> Is the field present?
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Symbol ] meth The name of the accessor.
+      # @param [ Hash ] options The options.
+      def create_accessors(name, meth, options = {})
+        generated_field_methods.module_eval do
+          define_method(meth) { read_attribute(name) }
+          define_method("#{meth}=") { |value| write_attribute(name, value) }
+          define_method("#{meth}?") do
+            attr = read_attribute(name)
+            (options[:type] == Boolean) ? attr == true : attr.present?
+          end
+        end
+      end
+
+      # Include the field methods as a module, so they can be overridden.
+      #
+      # @example Include the fields.
+      #   Person.generated_field_methods
+      def generated_field_methods
+        @generated_field_methods ||= begin
+          Module.new.tap do |mod|
+            include mod
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/finders.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Finders #:nodoc:
+
+    # Delegate to the criteria methods that are natural for creating a new
+    # criteria.
+    [ :all_in, :any_in, :any_of, :asc, :ascending, :avg, :desc, :descending,
+      :excludes, :limit, :max, :min, :not_in, :only, :order_by,
+      :skip, :sum, :where, :update, :update_all, :near ].each do |name|
+      define_method(name) do |*args|
+        criteria.send(name, *args)
+      end
+    end
+
+    # Find +Documents+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.all(:conditions => { :attribute => "value" })</tt>
+    def all(*args)
+      find(:all, *args)
+    end
+
+    # Returns a count of matching records in the database based on the
+    # provided arguments.
+    #
+    # <tt>Person.count(:conditions => { :attribute => "value" })</tt>
+    def count(*args)
+      Criteria.translate(self, false, *args).count
+    end
+
+    # Returns true if there are on document in database based on the
+    # provided arguments.
+    #
+    # <tt>Person.exists?(:conditions => { :attribute => "value" })</tt>
+    def exists?(*args)
+      Criteria.translate(self, false, *args).limit(1).count == 1
+    end
+
+    # Helper to initialize a new +Criteria+ object for this class, or return
+    # the currently scoped +Criteria+ object.
+    #
+    # Example:
+    #
+    # <tt>Person.criteria</tt>
+    def criteria(embedded = false)
+      scope_stack.last || Criteria.new(self, embedded)
+    end
+
+    # Find a +Document+ in several different ways.
+    #
+    # If a +String+ is provided, it will be assumed that it is a
+    # representation of a Mongo::ObjectID and will attempt to find a single
+    # +Document+ based on that id. If a +Symbol+ and +Hash+ is provided then
+    # it will attempt to find either a single +Document+ or multiples based
+    # on the conditions provided and the first parameter.
+    #
+    # Example:
+    #
+    # <tt>Person.find(:first, :conditions => { :attribute => "value" })</tt>
+    # <tt>Person.find(:all, :conditions => { :attribute => "value" })</tt>
+    # <tt>Person.find(BSON::ObjectId)</tt>
+    #
+    # Options:
+    #
+    # args: An assortment of finder options.
+    #
+    # Returns:
+    #
+    # A document or criteria.
+    def find(*args)
+      raise Errors::InvalidOptions.new(
+        :calling_document_find_with_nil_is_invalid, {}
+      ) if args[0].nil?
+      type, criteria = Criteria.parse!(self, false, *args)
+      case type
+      when :first then return criteria.one
+      when :last then return criteria.last
+      else
+        return criteria
+      end
+    end
+
+    # Find the first +Document+ given the conditions, or creates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_create_by(:attribute => "value")</tt>
+    def find_or_create_by(attrs = {})
+      find_or(:create, attrs)
+    end
+
+    # Find the first +Document+ given the conditions, or instantiates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_initialize_by(:attribute => "value")</tt>
+    def find_or_initialize_by(attrs = {})
+      find_or(:new, attrs)
+    end
+
+    # Find the first +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.first(:conditions => { :attribute => "value" })</tt>
+    def first(*args)
+      find(:first, *args)
+    end
+
+    # Find the last +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.last(:conditions => { :attribute => "value" })</tt>
+    def last(*args)
+      find(:last, *args)
+    end
+
+    # Find all documents in paginated fashion given the supplied arguments.
+    # If no parameters are passed just default to offset 0 and limit 20.
+    #
+    # Options:
+    #
+    # params: A +Hash+ of params to pass to the Criteria API.
+    #
+    # Example:
+    #
+    # <tt>Person.paginate(:conditions => { :field => "Test" }, :page => 1,
+    # :per_page => 20)</tt>
+    #
+    # Returns paginated array of docs.
+    def paginate(params = {})
+      Criteria.translate(self, false, params).paginate
+    end
+
+    protected
+    # Find the first object or create/initialize it.
+    def find_or(method, attrs = {})
+      first(:conditions => attrs) || send(method, attrs)
+    end
+
+    # Initializes and returns the current scope stack.
+    def scope_stack
+      scope_stack_for = Thread.current[:mongoid_scope_stack] ||= {}
+      scope_stack_for[object_id] ||= []
+    end
+
+    # Pushes the provided criteria onto the scope stack, and removes it after the
+    # provided block is yielded.
+    def with_scope(criteria)
+      scope_stack = self.scope_stack
+      scope_stack << criteria
+      begin
+        yield criteria
+      ensure
+        scope_stack.pop
+      end
+    end
+  end
+end

data/lib/mongoid/hierarchy.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Hierarchy #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      attr_accessor :_parent
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass.
+      #   Square.hereditary?
+      #
+      # @return [ true, false ] True if hereditary, false if not.
+      def hereditary?
+        Mongoid::Document > superclass
+      end
+    end
+
+    module InstanceMethods #:nodoc:
+
+      # Get all child +Documents+ to this +Document+, going n levels deep if
+      # necessary. This is used when calling update persistence operations from
+      # the root document, where changes in the entire tree need to be
+      # determined. Note that persistence from the embedded documents will
+      # always be preferred, since they are optimized calls... This operation
+      # can get expensive in domains with large hierarchies.
+      #
+      # @example Get all the document's children.
+      #   person._children
+      #
+      # @return [ Array<Document> ] All child documents in the hierarchy.
+      def _children
+        relations.inject([]) do |children, (name, metadata)|
+          children.tap do |kids|
+            if metadata.embedded? && name != "versions"
+              child = send(name)
+              child.to_a.each do |doc|
+                kids.push(doc).concat(doc._children)
+              end unless child.blank?
+            end
+          end
+        end
+      end
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass
+      #   Square.new.hereditary?
+      #
+      # @return [ true, false ] True if hereditary, false if not.
+      def hereditary?
+        self.class.hereditary?
+      end
+
+      # Sets up a child/parent association. This is used for newly created
+      # objects so they can be properly added to the graph.
+      #
+      # @example Set the parent document.
+      #   document.parentize(parent)
+      #
+      # @param [ Document ] document The parent document.
+      #
+      # @return [ Document ] The parent document.
+      def parentize(document)
+        self._parent = document
+      end
+
+      # Return the root document in the object graph. If the current document
+      # is the root object in the graph it will return self.
+      #
+      # @example Get the root document in the hierarchy.
+      #   document._root
+      #
+      # @return [ Document ] The root document in the hierarchy.
+      def _root
+        object = self
+        while (object._parent) do object = object._parent; end
+        object || self
+      end
+    end
+  end
+end

data/lib/mongoid/identity.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Identity #:nodoc:
+
+    attr_reader :document
+
+    # Create the identity for the document. The id will be set in either in
+    # the form of a Mongo object id or a composite key set up by defining
+    # a key on the document. The _type will be set to the document's class
+    # name.
+    #
+    # @example Create the id and set the type.
+    #   identity.create
+    def create
+      identify and type
+    end
+
+    # Create the new identity generator - this will be expanded in the future
+    # to support pk generators.
+    #
+    # @example
+    #   Identity.new(document)
+    #
+    # @param [ Document ] document The document to generate an id for.
+    #
+    # @return [ Identity ] The new identity object.
+    def initialize(document)
+      @document = document
+    end
+
+    private
+
+    # Return the proper id for the document. Will be an object id or its string
+    # representation depending on the configuration.
+    #
+    # @example Generate the id.
+    #   identity.generate_id
+    #
+    # @return [ Object ] The bson object id or its string equivalent.
+    def generate_id
+      id = BSON::ObjectId.new
+      document.using_object_ids? ? id : id.to_s
+    end
+
+    # Sets the id on the document. Will either set a newly generated id or
+    # build the composite key.
+    #
+    # @example Set the id.
+    #   identity.identify
+    def identify
+      document.id = compose.join(" ").identify if document.primary_key
+      document.id = generate_id if document.id.blank?
+    end
+
+    # Set the _type field on the document if the document is hereditary or in a
+    # polymorphic relation.
+    #
+    # @example Set the type.
+    #   identity.type
+    def type
+      document._type = document.class.name if typed?
+    end
+
+    # Generates the array of keys to build the id.
+    #
+    # @example Build the array for the keys.
+    #   identity.compose.
+    #
+    # @return [ Array<Object> ] The array of keys.
+    def compose
+      document.primary_key.collect do |key|
+        document.attributes[key]
+      end.reject { |val| val.nil? }
+    end
+
+    # Determines if the document stores the type information. This is if it is
+    # in a hierarchy, has subclasses, or is in a polymorphic relation.
+    #
+    # @example Check if the document is typed.
+    #   identity.typed?
+    #
+    # @return [ true, false ] True if typed, false if not.
+    def typed?
+      document.hereditary? ||
+        document.class.descendants.any? ||
+        document.polymorphic?
+    end
+  end
+end

data/lib/mongoid/indexes.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Indexes #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :index_options
+      self.index_options = {}
+    end
+
+    module ClassMethods #:nodoc
+
+      # Send the actual index creation comments to the MongoDB driver
+      def create_indexes
+        return unless index_options
+        current_collection = self._collection || set_collection
+        index_options.each do |name, options|
+          current_collection.create_index(name, options)
+        end
+      end
+
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      def add_indexes
+        if hereditary? && !index_options[:_type]
+          self.index_options[:_type] = {:unique => false, :background => true}
+        end
+        create_indexes if Mongoid.autocreate_indexes
+      end
+
+      # Adds an index on the field specified. Options can be :unique => true or
+      # :unique => false. It will default to the latter.
+      def index(name, options = { :unique => false })
+        self.index_options[name] = options
+        create_indexes if Mongoid.autocreate_indexes
+      end
+    end
+  end
+end