stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/inspection.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Inspection #:nodoc
+
+    # Returns the class name plus its attributes. If using dynamic fields will
+    # include those as well.
+    #
+    # Example:
+    #
+    # <tt>person.inspect</tt>
+    #
+    # Returns:
+    #
+    # A nice pretty string to look at.
+    def inspect
+      inspection = []
+      inspection.concat(inspect_fields).concat(inspect_dynamic_fields)
+      "#<#{self.class.name} _id: #{id}, #{inspection * ', '}>"
+    end
+
+    private
+
+    # Get an array of inspected fields for the document.
+    #
+    # Example:
+    #
+    # <tt>inspect_fields</tt>
+    #
+    # Returns:
+    #
+    # An array of pretty printed field values.
+    def inspect_fields
+      fields.map do |name, field|
+        "#{name}: #{@attributes[name].inspect}"
+      end
+    end
+
+    # Get an array of inspected dynamic fields for the document.
+    #
+    # Example:
+    #
+    # <tt>inspect_dynamic_fields</tt>
+    #
+    # Returns:
+    #
+    # An array of pretty printed dynamic field values.
+    def inspect_dynamic_fields
+      if Mongoid.allow_dynamic_fields
+        keys = @attributes.keys - fields.keys - relations.keys - ["_id", "_type"]
+        return keys.map do |name|
+          "#{name}: #{@attributes[name].inspect}"
+        end
+      else
+        []
+      end
+    end
+  end
+end

data/lib/mongoid/javascript/functions.yml

@@ -0,0 +1,37 @@
+aggregate:
+  "function(obj, prev) {
+     prev.count++;
+   }"
+
+group:
+  "function(obj, prev) {
+     prev.group.push(obj);
+   }"
+
+max:
+  "function(obj, prev) {
+     if (prev.max == 'start') {
+       prev.max = obj.[field];
+     }
+     if (prev.max < obj.[field]) {
+       prev.max = obj.[field];
+     }
+   }"
+
+min:
+  "function(obj, prev) {
+     if (prev.min == 'start') {
+       prev.min = obj.[field];
+     }
+     if (prev.min > obj.[field]) {
+       prev.min = obj.[field];
+     }
+   }"
+
+sum:
+  "function(obj, prev) {
+     if (prev.sum == 'start') {
+       prev.sum = 0;
+     }
+     prev.sum += obj.[field];
+  }"

data/lib/mongoid/javascript.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Javascript
+    # Constant for the file that defines all the js functions.
+    FUNCTIONS = File.join(File.dirname(__FILE__), "javascript", "functions.yml")
+
+    # Load the javascript functions and define a class method for each one,
+    # that memoizes the value.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Javascript.aggregate</tt>
+    YAML.load(File.read(FUNCTIONS)).each_pair do |key, function|
+      (class << self; self; end).class_eval <<-EOT
+        def #{key}
+          @#{key} ||= "#{function}"
+        end
+      EOT
+    end
+  end
+end

data/lib/mongoid/json.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  # This module is for hooking in to +ActiveModel+s serialization to let
+  # configuring the ability to include the root in JSON happen from the Mongoid
+  # config.
+  module JSON
+    extend ActiveSupport::Concern
+
+    # We need to redefine where the JSON configuration is getting defined,
+    # similar to +ActiveRecord+.
+    included do
+      undef_method :include_root_in_json
+      delegate :include_root_in_json, :to => ::Mongoid
+    end
+  end
+end

data/lib/mongoid/keys.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Keys
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :primary_key, :_identity
+      self._identity = { :type => BSON::ObjectId }
+
+      delegate \
+        :_id_type,
+        :primary_key,
+        :using_object_ids?, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Convenience method for returning the type of the id for this class.
+      #
+      # Example:
+      #
+      # <tt>Person._id_type</tt>
+      #
+      # Returns:
+      #
+      # The type of the id.
+      def _id_type
+        _identity[:type]
+      end
+
+      # Used for telling Mongoid on a per model basis whether to override the
+      # default +BSON::ObjectId+ and use a different type. This will be
+      # expanded in the future for requiring a PkFactory if the type is not a
+      # +BSON::ObjectId+ or +String+.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     identity :type => String
+      #   end
+      def identity(options = {})
+        self._identity = options
+      end
+
+      # Defines the field that will be used for the id of this +Document+. This
+      # set the id of this +Document+ before save to a parameterized version of
+      # the field that was supplied. This is good for use for readable URLS in
+      # web applications.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     key :first_name, :last_name
+      #   end
+      def key(*fields)
+        self.primary_key = fields
+        identity(:type => String)
+        set_callback :save, :before, :identify
+      end
+
+      # Convenience method for determining if we are using +BSON::ObjectIds+ as
+      # our id.
+      #
+      # Example:
+      #
+      # <tt>person.using_object_ids?</tt>
+      #
+      # Returns:
+      #
+      # true if we are using BSON::ObjectIds
+      def using_object_ids?
+        _id_type == BSON::ObjectId
+      end
+    end
+  end
+end

data/lib/mongoid/logger.rb

@@ -0,0 +1,18 @@
+module Mongoid
+  class Logger
+
+    delegate :info, :debug, :error, :fatal, :unknown, :to => :logger, :allow_nil => true
+
+    def warn(message)
+      logger.warn(message) if logger && logger.respond_to?(:warn)
+    end
+
+    def logger
+      Mongoid.logger
+    end
+
+    def inspect
+      "#<Mongoid::Logger:0x#{object_id.to_s(16)} @logger=#{logger.inspect}>"
+    end
+  end
+end

data/lib/mongoid/matchers/all.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class All < Default
+      # Return true if the attribute and first value in the hash are equal.
+      def matches?(value)
+        @attribute == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/default.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Default
+      # Creating a new matcher only requires the value.
+      def initialize(attribute)
+        @attribute = attribute
+      end
+      # Return true if the attribute and value are equal.
+      def matches?(value)
+        @attribute.is_a?(Array) && value.is_a?(String) ?
+          @attribute.include?(value) : value === @attribute
+      end
+
+      protected
+      # Return the first value in the hash.
+      def first(value)
+        value.values.first
+      end
+
+      # If object exists then compare, else return false
+      def determine(value, operator)
+        @attribute ? @attribute.send(operator, first(value)) : false
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/exists.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Exists < Default
+      # Return true if the attribute exists and checking for existence or
+      # return true if the attribute does not exist and checking for
+      # non-existence.
+      def matches?(value)
+        @attribute.nil? != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gt < Default
+      # Return true if the attribute is greater than the value.
+      def matches?(value)
+        determine(value, :>)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gte < Default
+      # Return true if the attribute is greater than or equal to the value.
+      def matches?(value)
+        determine(value, :>=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/in.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class In < Default
+      # Return true if the attribute is in the values.
+      def matches?(value)
+        value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lt < Default
+      # Return true if the attribute is less than the value.
+      def matches?(value)
+        determine(value, :<)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lte < Default
+      # Return true if the attribute is less than or equal to the value.
+      def matches?(value)
+        determine(value, :<=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/ne.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Ne < Default
+      # Return true if the attribute and first value are not equal.
+      def matches?(value)
+        @attribute != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/nin.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Nin < Default
+      # Return true if the attribute is not in the value list.
+      def matches?(value)
+        !value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/size.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Size < Default
+      # Return true if the attribute size is equal to the first value.
+      def matches?(value)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+require "mongoid/matchers/default"
+require "mongoid/matchers/all"
+require "mongoid/matchers/exists"
+require "mongoid/matchers/gt"
+require "mongoid/matchers/gte"
+require "mongoid/matchers/in"
+require "mongoid/matchers/lt"
+require "mongoid/matchers/lte"
+require "mongoid/matchers/ne"
+require "mongoid/matchers/nin"
+require "mongoid/matchers/size"
+
+module Mongoid #:nodoc:
+
+  # This module contains all the behavior for ruby implementations of MongoDB
+  # selectors.
+  module Matchers
+
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    #
+    # @example Does the document match?
+    #   document.matches?(:title => { "$in" => [ "test" ] })
+    #
+    # @param [ Hash ] selector The MongoDB selector.
+    #
+    # @return [ true, false ] True if matches, false if not.
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        return false unless matcher(key, value).matches?(value)
+      end; true
+    end
+
+    protected
+
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    #
+    # @example Get the matcher.
+    #   document.matcher(:title, { "$in" => [ "test" ] })
+    #
+    # @param [ Symbol, String ] key The field name.
+    # @param [ Object, Hash ] The value or selector.
+    #
+    # @return [ Matcher ] The matcher.
+    def matcher(key, value)
+      if value.is_a?(Hash)
+        name = "Mongoid::Matchers::#{value.keys.first.gsub("$", "").camelize}"
+        return name.constantize.new(attributes[key])
+      end
+      Default.new(attributes[key])
+    end
+  end
+end

data/lib/mongoid/modifiers/command.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Modifiers #:nodoc:
+    class Command #:nodoc:
+      include Mongoid::Safe
+
+      # Instantiate the new $inc modifier.
+      #
+      # Options:
+      #
+      # klass: The class to get the collection from.
+      # options: The options to get passed through to the driver.
+      def initialize(document, options = {})
+        @document, @options = document, options
+      end
+    end
+  end
+end

data/lib/mongoid/modifiers/inc.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Modifiers #:nodoc:
+    class Inc < Command #:nodoc:
+
+      # Execute the persistence operation. This will increment the provided
+      # field by the supplied value. If no field exists, it will be created and
+      # set to the value provided.
+      #
+      # Options:
+      #
+      # field: The field to increment.
+      # value: The number to increment by.
+      def persist(field, value)
+        @document.collection.update(
+          @document._selector,
+          { "$inc" => { field => value } },
+          :safe => safe_mode?(@options),
+          :multi => false
+        )
+      end
+    end
+  end
+end

data/lib/mongoid/modifiers.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require "mongoid/modifiers/command"
+require "mongoid/modifiers/inc"
+
+module Mongoid #:nodoc:
+  module Modifiers #:nodoc:
+    extend ActiveSupport::Concern
+
+    # Increment the field by the provided value, else if it doesn't exists set
+    # it to that value.
+    #
+    # Options:
+    #
+    # field: The field to increment.
+    # value: The value to increment by.
+    # options: Options to pass through to the driver.
+    def inc(field, value, options = {})
+      current = send(field)
+      write_attribute(field, (current ? (current + value) : value))
+      Inc.new(self, options).persist(field, value)
+      current + value
+    end
+  end
+end

data/lib/mongoid/multi_database.rb

@@ -0,0 +1,11 @@
+module Mongoid::MultiDatabase
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    def database; @database end
+    def set_database(name)
+      @database = name.to_s
+    end
+  end
+end

data/lib/mongoid/multi_parameter_attributes.rb

@@ -0,0 +1,80 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module MultiParameterAttributes
+    module Errors
+      # Raised when an error occurred while doing a mass assignment to an attribute through the
+      # <tt>attributes=</tt> method. The exception has an +attribute+ property that is the name of the
+      # offending attribute.
+      class AttributeAssignmentError < Mongoid::Errors::MongoidError
+        attr_reader :exception, :attribute
+        def initialize(message, exception, attribute)
+          @exception = exception
+          @attribute = attribute
+          @message = message
+        end
+      end
+
+      # Raised when there are multiple errors while doing a mass assignment through the +attributes+
+      # method. The exception has an +errors+ property that contains an array of AttributeAssignmentError
+      # objects, each corresponding to the error while assigning to an attribute.
+      class MultiparameterAssignmentErrors < Mongoid::Errors::MongoidError
+        attr_reader :errors
+        def initialize(errors)
+          @errors = errors
+        end
+      end
+    end
+
+    def process(attrs = nil)
+      if attrs
+        errors = []
+        attributes = {}
+        multi_parameter_attributes = {}
+
+        attrs.each_pair do |key, value|
+          if key =~ /^([^\(]+)\((\d+)([if])\)$/
+            key, index = $1, $2.to_i
+            (multi_parameter_attributes[key] ||= {})[index] = value.empty? ? nil : value.send("to_#{$3}")
+          else
+            attributes[key] = value
+          end
+        end
+
+        multi_parameter_attributes.each_pair do |key, values|
+          begin
+            values = (values.keys.min..values.keys.max).map { |i| values[i] }
+            klass = self.class.fields[key].try(:type)
+            attributes[key] = instantiate_object(klass, values)
+          rescue => e
+            errors << Errors::AttributeAssignmentError.new("error on assignment #{values.inspect} to #{key}", e, key)
+          end
+        end
+
+        unless errors.empty?
+          raise Errors::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
+        end
+
+        super attributes
+      else
+        super
+      end
+    end
+
+  protected
+
+    def instantiate_object(klass, values_with_empty_parameters)
+      return nil if values_with_empty_parameters.all? { |v| v.nil? }
+      
+      values = values_with_empty_parameters.collect { |v| v.nil? ? 1 : v }
+      
+      if klass == DateTime || klass == Date || klass == Time
+        klass.send(:convert_to_time, values)
+      elsif klass
+        klass.new *values
+      else
+        values
+      end
+    end
+
+  end
+end

data/lib/mongoid/named_scope.rb

@@ -0,0 +1,36 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module NamedScope
+    # Creates a named_scope for the +Document+, similar to ActiveRecord's
+    # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+    # chained.
+    #
+    # Example:
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :active, :type => Boolean
+    #     field :count, :type => Integer
+    #
+    #     named_scope :active, :where => { :active => true }
+    #     named_scope :count_gt_one, :where => { :count.gt => 1 }
+    #     named_scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+    #   end
+    def named_scope(name, conditions = {}, &block)
+      name = name.to_sym
+      scopes[name] = Scope.new(conditions, &block)
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scope = scopes[:#{name}]
+          scope.extend(criteria.fuse(scope.conditions.scoped(*args)))
+        end
+      EOT
+    end
+    alias :scope :named_scope
+
+    # Return the scopes or default to an empty +Hash+.
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+  end
+end

data/lib/mongoid/nested_attributes.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module NestedAttributes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |_, value| value.blank? } }
+
+      # Used when needing to update related models from a parent relation. Can
+      # be used on embedded or referenced relations.
+      #
+      # @example Defining nested attributes.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #
+      #     embeds_many :addresses
+      #     embeds_one :game
+      #     references_many :posts
+      #
+      #     accepts_nested_attributes_for :addresses, :game, :posts
+      #   end
+      #
+      # @param [ Array<Symbol>, Hash ] *args A list of relation names, followed
+      #   by a hash of options.
+      #
+      # @option *args [ true, false ] :allow_destroy Can deletion occur?
+      # @option *args [ Proc ] :reject_if Block to reject documents with.
+      # @option *args [ Integer ] :limit The max number to create.
+      # @option *args [ true, false ] :update_only Only update existing docs.
+      def accepts_nested_attributes_for(*args)
+        options = args.extract_options!
+        options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
+        args.each do |name|
+          define_method("#{name}_attributes=") do |attrs|
+            relation = relations[name.to_s]
+            relation.nested_builder(attrs, options).build(self)
+          end
+        end
+      end
+    end
+  end
+end