stonegao-mongoid 2.0.0.rc.6

data/lib/config/locales/pt.yml

@@ -0,0 +1,43 @@
+pt:
+  activemodel:
+    errors:
+      messages:
+        taken: já está utilizada
+
+  mongoid:
+    errors:
+      messages:
+        document_not_found:
+          Nenhum documento encontrado para a classe %{klass} com os id(s) %{identifiers}.
+        invalid_database:
+          A base de dados deverá ser uma Mongo::DB, em vez de %{name}.
+        invalid_type:
+          O campo foi definido como %{klass}, mas recebeu uma instância de %{other} com
+          o valor %{value}.
+        unsupported_version:
+          MongoDB %{version} não é suportada, por favor actualize para a 
+          versão %{mongo_version}.
+        validations:
+          A validação falhou - %{errors}.
+        invalid_collection:
+          O acesso à colecção para %{klass} não é permitido porque
+          é um documento embebido, por favor aceda à colecção através
+          do documento raiz.
+        invalid_field:
+          Não é permitido definir um campo com o nome %{name}. Não defina
+          campos que entrem em conflito com os nomes dos atributos internos e métodos 
+          do Mongoid. Use Document#instance_methods para consultar esses nomes.
+        too_many_nested_attribute_records:
+          A aceitação de atributos encadeados para %{association} encontra-se limitada
+          a %{limit} registros.
+        embedded_in_must_have_inverse_of:
+          As opções para uma associação embedded_in devem incluir inverse_of.
+        dependent_only_references_one_or_many:
+          A opção The dependent => destroy|delete que é fornecida
+          é apenas válida para associações references_one ou references_many.
+        association_cant_have_inverse_of:
+          A definição de inverse_of nesta associação não é permitida. Apenas
+          use esta opção em embedded_in ou references_many como lista.
+        unsaved_document:
+          You cannot call create or create! through a relational association
+          relation (%{document}) who's parent (%{base}) is not already saved.

data/lib/config/locales/ro.yml

@@ -0,0 +1,49 @@
+ro:
+  activemodel:
+    errors:
+      messages:
+        taken: este deja folosit
+
+  mongoid:
+    errors:
+      messages:
+        document_not_found:
+          Nu există document în clasa %{klass} cu id %{identifiers}.
+        invalid_database:
+          Baza de date ar trebui să fie de tipul Mongo::DB, nu %{name}.
+        invalid_type:
+          Câmpul a fost definit ca şi un(o) %{klass}, dar valoarea
+          recepţionată %{value} este de clasa %{other}.
+        unsupported_version:
+          Versiunea MongoDB %{version} nu este suportată.
+          Vă rugăm să folosiţi versiunea %{mongo_version}.
+        validations:
+          Validare nereuşită - %{errors}.
+        invalid_collection:
+          Accesul la colecţie din clasa %{klass} este interzisă, fiindcă
+          este un document încorporat. Vă rugăm accesaţi colecţia din
+          documentul rădăcină.
+        invalid_field:
+          Folosirea denumirii %{name} ptr. un câmp este interzisă. Vă
+          rugăm să evitaţi utilizarea acelor cuvinte care intră în conflict
+          cu denumirile folosite de proprietăţile sau metodele Mongoid-lui.
+          Folosiţi comanda Document#instance_methods pentru a afla care
+          sunt acestea.
+        too_many_nested_attribute_records:
+          În cazul %{association} folosirea atributelor îmbricate este
+          limitat la %{limit} înregistrări.
+        embedded_in_must_have_inverse_of:
+          Folosirea opţiunii  inverse_of este obligatorie în cazul
+          asociaţiilor de tip  embedded_in.
+        dependent_only_references_one_or_many:
+          Opţiunea dependent => destroy|delete poate fi folosită doar în
+          cazul asociaţiilor de tip references_one sau references_many.
+        association_cant_have_inverse_of:
+          Folosire opţiunii inverse_of la acest tip de asociaţie este
+          interzisă. Aceasta poate fi folosită doar la asociaţiile de
+          tip embedded_in sau references_many as array.
+        calling_document_find_with_nil_is_invalid:
+          Folosirea metodei Document#find cu valoarea nil este invalidă.
+        unsaved_document:
+          You cannot call create or create! through a relational association
+          relation (%{document}) who's parent (%{base}) is not already saved.

data/lib/config/locales/sv.yml

@@ -0,0 +1,43 @@
+sv:
+  activemodel:
+    errors:
+      messages:
+        taken: har redan använts
+
+  mongoid:
+    errors:
+      messages:
+        document_not_found:
+          Inget dokument kunde hittas för klass %{klass} med id %{identifiers}.
+        invalid_database:
+          Databasen bör vara Mongo::DB, inte %{name}.
+        invalid_type:
+          Fältet var definerat som %{klass}, men fick %{other} med
+          värdet %{value}.
+        unsupported_version:
+          MongoDB %{version} stöds ej, vänligen upgradera
+          till %{mongo_version}.
+        validations:
+          Validering misslyckades - %{errors}.
+        invalid_collection:
+          Tillgång till kollektionen för %{klass} är inte tillåten eftersom den
+          är ett inbäddat dokument, vänligen accessa kollektionen från
+          rotdokumentet.
+        invalid_field:
+          Att definera ett fält med namnet %{name} är inte tillåtet. Definera inte
+          fält som är i konflikt med Mongoids interna attribut eller metod
+          namn. Använd Document#instance_methods för att se vilka namn detta innefattar.
+        too_many_nested_attribute_records:
+          Acceptans av nästlade attribut för %{association} är begränsat
+          till %{limit} register.
+        embedded_in_must_have_inverse_of:
+          Alternativ för en embedded_in association måste innehålla inverse_of.
+        dependent_only_references_one_or_many:
+          Alternativet dependent => destroy|delete som angavs
+          är endast giltigt för references_one eller references_many associationer.
+        association_cant_have_inverse_of:
+          Att definera inverse_of på denna association är inte tillåtet. Använd
+          endast detta alternativ på embedded_in eller references_many as array.
+        unsaved_document:
+          You cannot call create or create! through a relational association
+          relation (%{document}) who's parent (%{base}) is not already saved.

data/lib/config/locales/zh-CN.yml

@@ -0,0 +1,34 @@
+en:
+  activemodel:
+    errors:
+      messages:
+        taken: 已占用
+
+  mongoid:
+    errors:
+      messages:
+        document_not_found:
+          没有发现类是%{klass}id(s)是%{identifiers}的文档
+        invalid_database:
+          数据库应该是Mongo::DB,而不是%{name}.
+        invalid_type:
+          在类%{klass}中定义了字段,实际值是%{value}的%{other}.
+        unsupported_version:
+          MongoDB %{version} 版本已过期，请升级到 %{mongo_version}.
+        validations:
+          校验失败 - %{errors}.
+        invalid_collection:
+          不允许直接访问嵌入式的集合%{klass} , 请从文档的根访问集合.
+        invalid_field:
+          字段的名字不允许为 %{name}. 你不应该定义跟Mongoid内部属性或者方法相同的名字，详细请看Use Document#instance_methods.
+        too_many_nested_attribute_records:
+          被关联的%{association} 嵌入式属性不能超过 %{limit}.
+        embedded_in_must_have_inverse_of:
+          embedded_in的关联属性必须包含inverse_of.
+        dependent_only_references_one_or_many:
+          dependent => destroy|delete 选项只有在references_one或者references_many时候有效.
+        association_cant_have_inverse_of:
+          在当前的关联中，不允许定义inverse_of去,其只有在embedded_in或者references_many是数组的情况下使用
+        unsaved_document:
+          You cannot call create or create! through a relational association
+          relation (%{document}) who's parent (%{base}) is not already saved.

data/lib/mongoid/atomicity.rb

@@ -0,0 +1,111 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module contains the logic for supporting atomic operations against the
+  # database.
+  #
+  # @todo Durran: Refactor class out into separate objects for each type of
+  #   update.
+  module Atomicity
+    extend ActiveSupport::Concern
+
+    # Get all the atomic updates that need to happen for the current
+    # +Document+. This includes all changes that need to happen in the
+    # entire hierarchy that exists below where the save call was made.
+    #
+    # @note
+    #   MongoDB does not allow "conflicting modifications" to be
+    #   performed in a single operation.  Conflicting modifications are
+    #   detected by the 'haveConflictingMod' function in MongoDB.
+    #   Examination of the code suggests that two modifications (a $set
+    #   and a $pushAll, for example) conflict if:
+    #     (1) the key paths being modified are equal.
+    #     (2) one key path is a prefix of the other.
+    #   So a $set of 'addresses.0.street' will conflict with a $pushAll
+    #   to 'addresses', and we will need to split our update into two
+    #   pieces.  We do not, however, attempt to match MongoDB's logic
+    #   exactly.  Instead, we assume that two updates conflict if the
+    #   first component of the two key paths matches.
+    #
+    # @example Get the updates that need to occur.
+    #   person._updates
+    #
+    # @return [ Hash ] The updates and their modifiers.
+    def _updates
+      processed = {}
+
+      _children.inject({ "$set" => _sets, "$pushAll" => {}, :other => {} }) do |updates, child|
+        changes = child._sets
+        updates["$set"].update(changes)
+        unless changes.empty?
+          processed[child._conficting_modification_key] = true
+        end
+
+        if processed.has_key?(child._conficting_modification_key)
+          target = :other
+        else
+          target = "$pushAll"
+        end
+
+        child._pushes.each do |attr, val|
+          if updates[target].has_key?(attr)
+            updates[target][attr] << val
+          else
+            updates[target].update({attr => [val]})
+          end
+        end
+        updates
+      end.delete_if do |key, value|
+        value.empty?
+      end
+    end
+
+    protected
+
+    # Get the key used to check for conflicting modifications.  For now, we
+    # just use the first component of _path, and discard the first period
+    # and everything that follows.
+    #
+    # @example Get the key.
+    #   person._conflicting_modification_key
+    #
+    # @return [ String ] The conflicting key.
+    def _conficting_modification_key
+      _path.sub(/\..*/, '')
+    end
+
+    # Get all the push attributes that need to occur.
+    #
+    # @example Get the pushes.
+    #   person._pushes
+    #
+    # @return [ Hash ] The $pushAll operations.
+    def _pushes
+      pushable? ? { _path => to_hash } : {}
+    end
+
+    # Determine if the document can be pushed.
+    #
+    # @example Is this pushable?
+    #   person.pushable?
+    #
+    # @return [ true, false ] Is the document new and embedded?
+    def pushable?
+      new_record? && embedded_many? && _parent.persisted?
+    end
+
+    # Get all the attributes that need to be set.
+    #
+    # @example Get the sets.
+    #   person._sets
+    #
+    # @return [ Hash ] The $set operations.
+    def _sets
+      if changed? && !new_record?
+        setters
+      else
+        embedded_one? && new_record? ? { _path => to_hash } : {}
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -0,0 +1,251 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module contains the logic for handling the internal attributes hash,
+  # and how to get and set values.
+  module Attributes
+
+    # Returns the object type. This corresponds to the name of the class that
+    # this document is, which is used in determining the class to
+    # instantiate in various cases.
+    #
+    # @example Get the type.
+    #   person._type
+    #
+    # @return [ String ] The name of the class the document is.
+    def _type
+      @attributes["_type"]
+    end
+
+    # Set the type of the document. This should be the name of the class.
+    #
+    # @example Set the type
+    #   person._type = "Person"
+    #
+    # @param [ String ] new_type The name of the class.
+    #
+    # @return [ String ] the new type.
+    def _type=(new_type)
+      @attributes["_type"] = new_type
+    end
+
+    # Determine if an attribute is present.
+    #
+    # @example Is the attribute present?
+    #   person.attribute_present?("title")
+    #
+    # @param [ String, Symbol ] name The name of the attribute.
+    #
+    # @return [ true, false ] True if present, false if not.
+    def attribute_present?(name)
+      !read_attribute(name).blank?
+    end
+
+    # Get the id associated with this object. This will pull the _id value out
+    # of the attributes.
+    #
+    # @example Get the id.
+    #   person.id
+    #
+    # @return [ BSON::ObjectId, String ] The id of the document.
+    def id
+      @attributes["_id"]
+    end
+    alias :_id :id
+
+    # Set the id of the document to a new one.
+    #
+    # @example Set the id.
+    #   person.id = BSON::ObjectId.new
+    #
+    # @param [ BSON::ObjectId, String ] new_id The new id.
+    #
+    # @return [ BSON::ObjectId, String ] The new id.
+    def id=(new_id)
+      @attributes["_id"] = _id_type.set(new_id)
+    end
+    alias :_id= :id=
+
+    # Used for allowing accessor methods for dynamic attributes.
+    #
+    # @param [ String, Symbol ] name The name of the method.
+    # @param [ Array ] *args The arguments to the method.
+    def method_missing(name, *args)
+      attr = name.to_s
+      return super unless @attributes.has_key?(attr.reader)
+      if attr.writer?
+        # "args.size > 1" allows to simulate 1.8 behavior of "*args"
+        write_attribute(attr.reader, (args.size > 1) ? args : args.first)
+      else
+        read_attribute(attr.reader)
+      end
+    end
+
+    # Process the provided attributes casting them to their proper values if a
+    # field exists for them on the document. This will be limited to only the
+    # attributes provided in the suppied +Hash+ so that no extra nil values get
+    # put into the document's attributes.
+    #
+    # @example Process the attributes.
+    #   person.process(:title => "sir", :age => 40)
+    #
+    # @param [ Hash ] attrs The attributes to set.
+    def process(attrs = nil)
+      pending = {}
+      sanitize_for_mass_assignment(attrs || {}).each_pair do |key, value|
+        if set_allowed?(key)
+          write_attribute(key, value)
+        else
+          pending[key.to_s] = value and next if relations.has_key?(key.to_s)
+          send("#{key}=", value)
+        end
+      end
+      yield self if block_given?
+      process_relations(pending)
+      setup_modifications
+    end
+
+    # Read a value from the document attributes. If the value does not exist
+    # it will return nil.
+    #
+    # @example Read an attribute.
+    #   person.read_attribute(:title)
+    #
+    # @example Read an attribute (alternate syntax.)
+    #   person[:title]
+    #
+    # @param [ String, Symbol ] name The name of the attribute to get.
+    #
+    # @return [ Object ] The value of the attribute.
+    def read_attribute(name)
+      access = name.to_s
+      value = @attributes[access]
+      typed_value = fields.has_key?(access) ? fields[access].get(value) : value
+      accessed(access, typed_value)
+    end
+    alias :[] :read_attribute
+
+    # Remove a value from the +Document+ attributes. If the value does not exist
+    # it will fail gracefully.
+    #
+    # @example Remove the attribute.
+    #   person.remove_attribute(:title)
+    #
+    # @param [ String, Symbol ] name The name of the attribute to remove.
+    def remove_attribute(name)
+      access = name.to_s
+      modify(access, @attributes.delete(name.to_s), nil)
+    end
+
+    # Override respond_to? so it responds properly for dynamic attributes.
+    #
+    # @example Does this object respond to the method?
+    #   person.respond_to?(:title)
+    #
+    # @param [ Array ] *args The name of the method.
+    #
+    # @return [ true, false ] True if it does, false if not.
+    def respond_to?(*args)
+      (Mongoid.allow_dynamic_fields &&
+        @attributes &&
+        @attributes.has_key?(args.first.to_s)
+      ) || super
+    end
+
+    # Write a single attribute to the document attribute hash. This will
+    # also fire the before and after update callbacks, and perform any
+    # necessary typecasting.
+    #
+    # @example Write the attribute.
+    #   person.write_attribute(:title, "Mr.")
+    #
+    # @example Write the attribute (alternate syntax.)
+    #   person[:title] = "Mr."
+    #
+    # @param [ String, Symbol ] name The name of the attribute to update.
+    # @param [ Object ] value The value to set for the attribute.
+    def write_attribute(name, value)
+      access = name.to_s
+      modify(access, @attributes[access], typed_value_for(access, value))
+    end
+    alias :[]= :write_attribute
+
+    # Writes the supplied attributes hash to the document. This will only
+    # overwrite existing attributes if they are present in the new +Hash+, all
+    # others will be preserved.
+    #
+    # @example Write the attributes.
+    #   person.write_attributes(:title => "Mr.")
+    #
+    # @example Write the attributes (alternate syntax.)
+    #   person.attributes = { :title => "Mr." }
+    #
+    # @param [ Hash ] attrs The new attributes to set.
+    def write_attributes(attrs = nil)
+      process(attrs || {})
+      if new_record? && id.blank?
+        identify
+      end
+    end
+    alias :attributes= :write_attributes
+
+    protected
+
+    # Get the default values for the attributes.
+    #
+    # @example Get the defaults.
+    #   person.default_attributes
+    #
+    # @return [ Hash ] The default values for each field.
+    def default_attributes
+      default_values = defaults
+      default_values.each_pair do |key, val|
+        default_values[key] = typed_value_for(key, val.call) if val.respond_to?(:call)
+      end
+      default_values || {}
+    end
+
+    # Process all the pending relations that needed to wait until ids were set
+    # to fire off.
+    #
+    # @example Process the relations.
+    #   document.process_relations({ "addressable" => person })
+    #
+    # @param [ Hash ] pending The pending relation values.
+    def process_relations(pending)
+      pending.each_pair do |name, value|
+        metadata = relations[name]
+        if value.is_a?(Hash)
+          metadata.nested_builder(value, {}).build(self)
+        else
+          send("#{name}=", value, :binding => true)
+        end
+      end
+    end
+
+    # Return true if dynamic field setting is enabled.
+    #
+    # @example Is a set allowed for this name?
+    #   person.set_allowed?(:title)
+    #
+    # @param [ String, Symbol ] key The name of the field.
+    #
+    # @return [ true, false ] True if allowed, false if not.
+    def set_allowed?(key)
+      Mongoid.allow_dynamic_fields && !respond_to?("#{key}=")
+    end
+
+    # Return the typecasted value for a field.
+    #
+    # @example Get the value typecasted.
+    #   person.typed_value_for(:title, :sir)
+    #
+    # @param [ String, Symbol ] key The field name.
+    # @param [ Object ] value The uncast value.
+    #
+    # @return [ Object ] The cast value.
+    def typed_value_for(key, value)
+      fields.has_key?(key) ? fields[key].set(value) : value
+    end
+  end
+end

data/lib/mongoid/callbacks.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Callbacks
+    extend ActiveSupport::Concern
+    included do
+      extend ActiveModel::Callbacks
+      include ActiveModel::Validations::Callbacks
+
+      define_model_callbacks :initialize, :only => :after
+      define_model_callbacks :create, :destroy, :save, :update
+    end
+  end
+end

data/lib/mongoid/collection.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+require "mongoid/collections/operations"
+require "mongoid/collections/cyclic_iterator"
+require "mongoid/collections/master"
+require "mongoid/collections/slaves"
+
+module Mongoid #:nodoc
+
+  # This class is the Mongoid wrapper to the Mongo Ruby driver's collection
+  # object.
+  class Collection
+    attr_reader :counter, :name
+
+    # All write operations should delegate to the master connection. These
+    # operations mimic the methods on a Mongo:Collection.
+    #
+    # @example Delegate the operation.
+    #   collection.save({ :name => "Al" })
+    Collections::Operations::PROXIED.each do |name|
+      define_method(name) { |*args| master.send(name, *args) }
+    end
+
+    # 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 Send the operation to the master or slaves.
+    #   collection.directed
+    #
+    # @param [ Hash ] options The operation options.
+    #
+    # @option options [ true, false ] :cache Should the query cache in memory?
+    # @option options [ true, false ] :enslave Send the write to the slave?
+    #
+    # @return [ Master, Slaves ] The connection to use.
+    def directed(options = {})
+      options.delete(:cache)
+      enslave = options.delete(:enslave) || @klass.enslaved?
+      enslave ? master_or_slaves : master
+    end
+
+    # Find documents from the database given a selector and options.
+    #
+    # @example Find documents in the collection.
+    #   collection.find({ :test => "value" })
+    #
+    # @param [ Hash ] selector The query selector.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Cursor ] The results.
+    def find(selector = {}, options = {})
+      cursor = Mongoid::Cursor.new(@klass, self, directed(options).find(selector, options))
+      if block_given?
+        yield cursor; cursor.close
+      else
+        cursor
+      end
+    end
+
+    # Find the first document from the database given a selector and options.
+    #
+    # @example Find one document.
+    #   collection.find_one({ :test => "value" })
+    #
+    # @param [ Hash ] selector The query selector.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Document, nil ] A matching document or nil if none found.
+    def find_one(selector = {}, options = {})
+      directed(options).find_one(selector, options)
+    end
+
+    # Initialize a new Mongoid::Collection, setting up the master, slave, and
+    # name attributes. Masters will be used for writes, slaves for reads.
+    #
+    # @example Create the new collection.
+    #   Collection.new(masters, slaves, "test")
+    #
+    # @param [ Class ] klass The class the collection is for.
+    # @param [ String ] name The name of the collection.
+    def initialize(klass, name)
+      @klass, @name = klass, name
+    end
+
+    # Perform a map/reduce on the documents.
+    #
+    # @example Perform the map/reduce.
+    #   collection.map_reduce(map, reduce)
+    #
+    # @param [ String ] map The map javascript function.
+    # @param [ String ] reduce The reduce javascript function.
+    # @param [ Hash ] options The options to pass to the db.
+    #
+    # @return [ Cursor ] The results.
+    def map_reduce(map, reduce, options = {})
+      directed(options).map_reduce(map, reduce, options)
+    end
+    alias :mapreduce :map_reduce
+
+    # Return the object responsible for writes to the database. This will
+    # always return a collection associated with the Master DB.
+    #
+    # @example Get the master connection.
+    #   collection.master
+    #
+    # @return [ Master ] The master connection.
+    def master
+      db = Mongoid.databases[@klass.database] || Mongoid.master
+      @master ||= Collections::Master.new(db, @name)
+    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 Get the slaves array.
+    #   collection.slaves
+    #
+    # @return [ Slaves ] The pool of slave connections.
+    def slaves
+      slaves = Mongoid.databases["#{@klass.database}_slaves"] || Mongoid.slaves
+      @slaves ||= Collections::Slaves.new(slaves, @name)
+    end
+
+    protected
+
+    # Determine if the read is going to the master or the slaves.
+    #
+    # @example Use the master or slaves?
+    #   collection.master_or_slaves
+    #
+    # @return [ Master, Slaves ] Master if not slaves exist, or slaves.
+    def master_or_slaves
+      slaves.empty? ? master : slaves
+    end
+  end
+end