mongoid-braxton 2.0.2

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

@@ -0,0 +1,33 @@
+zh-CN:
+  mongoid:
+    errors:
+      messages:
+        blank:
+          不能为空
+        taken:
+          已占用
+        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.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+
+# Copyright (c) 2009 - 2011 Durran Jordan and friends.
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+require "delegate"
+require "time"
+require "ostruct"
+require "active_support/core_ext"
+require 'active_support/json'
+require "active_support/inflector"
+require "active_support/time_with_zone"
+require "active_model"
+require "active_model/callbacks"
+require "active_model/conversion"
+require "active_model/errors"
+require "active_model/mass_assignment_security"
+require "active_model/naming"
+require "active_model/serialization"
+require "active_model/translation"
+require "active_model/validator"
+require "active_model/validations"
+require "mongo"
+require "mongoid/errors"
+require "mongoid/extensions"
+require "mongoid/safe"
+require "mongoid/relations"
+require "mongoid/atomicity"
+require "mongoid/attributes"
+require "mongoid/callbacks"
+require "mongoid/collection"
+require "mongoid/collections"
+require "mongoid/config"
+require "mongoid/contexts"
+require "mongoid/copyable"
+require "mongoid/criteria"
+require "mongoid/cursor"
+require "mongoid/default_scope"
+require "mongoid/dirty"
+require "mongoid/extras"
+require "mongoid/factory"
+require "mongoid/field"
+require "mongoid/fields"
+require "mongoid/finders"
+require "mongoid/hierarchy"
+require "mongoid/identity"
+require "mongoid/indexes"
+require "mongoid/inspection"
+require "mongoid/javascript"
+require "mongoid/json"
+require "mongoid/keys"
+require "mongoid/logger"
+require "mongoid/matchers"
+require "mongoid/multi_parameter_attributes"
+require "mongoid/multi_database"
+require "mongoid/named_scope"
+require "mongoid/nested_attributes"
+require "mongoid/observer"
+require "mongoid/paths"
+require "mongoid/persistence"
+require "mongoid/safety"
+require "mongoid/scope"
+require "mongoid/serialization"
+require "mongoid/sharding"
+require "mongoid/state"
+require "mongoid/timestamps"
+require "mongoid/validations"
+require "mongoid/versioning"
+require "mongoid/components"
+require "mongoid/paranoia"
+require "mongoid/document"
+
+# add railtie
+if defined?(Rails)
+  require "mongoid/railtie"
+end
+
+# add english load path by default
+I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml")
+
+module Mongoid #:nodoc
+
+  MONGODB_VERSION = "1.6.0"
+
+  class << self
+
+    # Sets the Mongoid configuration options. Best used by passing a block.
+    #
+    # @example Set up configuration options.
+    #
+    #   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
+    #
+    # @return [ Config ] The configuration obejct.
+    def configure
+      config = Mongoid::Config
+      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 Delegate the configuration methods.
+  #   Mongoid.database = Mongo::Connection.new.db("test")
+  (Mongoid::Config.public_instance_methods(false) +
+    ActiveModel::Observing::ClassMethods.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/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._conflicting_modification_key] = true
+        end
+
+        if processed.has_key?(child._conflicting_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 _conflicting_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 => as_document } : {}
+    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 => as_document } : {}
+      end
+    end
+  end
+end

data/lib/mongoid/attributes.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+require "mongoid/attributes/processing"
+
+module Mongoid #:nodoc:
+
+  # This module contains the logic for handling the internal attributes hash,
+  # and how to get and set values.
+  module Attributes
+    include Processing
+
+    attr_reader :attributes
+    alias :raw_attributes :attributes
+
+    # 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.
+    #
+    # @since 1.0.0
+    def attribute_present?(name)
+      !read_attribute(name).blank?
+    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.
+    #
+    # @since 1.0.0
+    def read_attribute(name)
+      access = name.to_s
+      value = attributes[access]
+      accessed(access, 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.
+    #
+    # @since 1.0.0
+    def remove_attribute(name)
+      access = name.to_s
+      modify(access, attributes.delete(access), 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.
+    #
+    # @since 1.0.0
+    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.
+    #
+    # @since 1.0.0
+    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.
+    # @param [ Boolean ] guard_protected_attributes False to skip mass assignment protection.
+    #
+    # @since 1.0.0
+    def write_attributes(attrs = nil, guard_protected_attributes = true)
+      process(attrs, guard_protected_attributes) do |document|
+        document.identify if new? && id.blank?
+      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.
+    #
+    # @since 1.0.0
+    #
+    # @raise [ RuntimeError ] Always
+    # @since 2.0.0.rc.8
+    def default_attributes
+      raise "default_attributes is no longer valid. Plase use: apply_default_attributes."
+    end
+
+    # Set any missing default values in the attributes.
+    #
+    # @example Get the raw attributes after defaults have been applied.
+    #   person.apply_default_attributes
+    #
+    # @return [ Hash ] The raw attributes.
+    #
+    # @since 2.0.0.rc.8
+    def apply_default_attributes
+      (@attributes ||= {}).tap do |h|
+        defaults.each_pair do |key, val|
+          unless h.has_key?(key)
+            h[key] = val.respond_to?(:call) ? typed_value_for(key, val.call) : val
+          end
+        end
+      end
+    end
+
+    # 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?
+        write_attribute(attr.reader, (args.size > 1) ? args : args.first)
+      else
+        read_attribute(attr.reader)
+      end
+    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.
+    #
+    # @since 1.0.0
+    def typed_value_for(key, value)
+      fields.has_key?(key) ? fields[key].set(value) : value
+    end
+  end
+end