mongoid-rails2 1.9.3

data/lib/mongoid/extensions.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+require "mongoid/extensions/time_conversions"
+require "mongoid/extensions/array/accessors"
+require "mongoid/extensions/array/aliasing"
+require "mongoid/extensions/array/assimilation"
+require "mongoid/extensions/array/conversions"
+require "mongoid/extensions/array/parentization"
+require "mongoid/extensions/big_decimal/conversions"
+require "mongoid/extensions/binary/conversions"
+require "mongoid/extensions/boolean/conversions"
+require "mongoid/extensions/date/conversions"
+require "mongoid/extensions/datetime/conversions"
+require "mongoid/extensions/float/conversions"
+require "mongoid/extensions/hash/accessors"
+require "mongoid/extensions/hash/assimilation"
+require "mongoid/extensions/hash/conversions"
+require "mongoid/extensions/hash/criteria_helpers"
+require "mongoid/extensions/hash/scoping"
+require "mongoid/extensions/integer/conversions"
+require "mongoid/extensions/nil/assimilation"
+require "mongoid/extensions/object/conversions"
+require "mongoid/extensions/proc/scoping"
+require "mongoid/extensions/string/conversions"
+require "mongoid/extensions/string/inflections"
+require "mongoid/extensions/symbol/inflections"
+require "mongoid/extensions/objectid/conversions"
+
+class Array #:nodoc
+  include Mongoid::Extensions::Array::Accessors
+  include Mongoid::Extensions::Array::Assimilation
+  include Mongoid::Extensions::Array::Conversions
+  include Mongoid::Extensions::Array::Parentization
+end
+
+class BigDecimal #:nodoc
+  extend Mongoid::Extensions::BigDecimal::Conversions
+end
+
+class Binary #:nodoc
+  extend Mongoid::Extensions::Binary::Conversions
+end
+
+class Boolean #:nodoc
+  extend Mongoid::Extensions::Boolean::Conversions
+end
+
+class DateTime #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+  extend Mongoid::Extensions::DateTime::Conversions
+end
+
+class Date #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+  extend Mongoid::Extensions::Date::Conversions
+end
+
+class Float #:nodoc
+  extend Mongoid::Extensions::Float::Conversions
+end
+
+class Hash #:nodoc
+  include Mongoid::Extensions::Hash::Accessors
+  include Mongoid::Extensions::Hash::Assimilation
+  include Mongoid::Extensions::Hash::CriteriaHelpers
+  include Mongoid::Extensions::Hash::Scoping
+  include Mongoid::Extensions::Hash::Conversions
+end
+
+class Integer #:nodoc
+  extend Mongoid::Extensions::Integer::Conversions
+end
+
+class NilClass #:nodoc
+  include Mongoid::Extensions::Nil::Assimilation
+end
+
+class Object #:nodoc:
+  include Mongoid::Extensions::Object::Conversions
+end
+
+class Proc #:nodoc:
+  include Mongoid::Extensions::Proc::Scoping
+end
+
+class String #:nodoc
+  include Mongoid::Extensions::String::Inflections
+  extend Mongoid::Extensions::String::Conversions
+end
+
+class Symbol #:nodoc
+  remove_method :size if instance_methods.include? :size # temporal fix for ruby 1.9
+  include Mongoid::Extensions::Symbol::Inflections
+end
+
+class Time #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+end
+
+class BSON::ObjectId #:nodoc
+  extend Mongoid::Extensions::ObjectId::Conversions
+end

data/lib/mongoid/extras.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extras #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_accessor :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,59 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Field
+    attr_reader :name, :type
+
+    # Determine if the field is able to be accessible via a mass update.
+    #
+    # Returns:
+    #
+    # true if accessible, false if not.
+    def accessible?
+      !!@accessible
+    end
+
+    # Get the default value for the field.
+    #
+    # Returns:
+    #
+    # The primitive value or a copy of the default.
+    def default
+      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 = {})
+      @name, @default = name, options[:default]
+      @copyable = (@default.is_a?(Array) || @default.is_a?(Hash))
+      @type = options[:type] || String
+      @accessible = options.has_key?(:accessible) ? options[:accessible] : true
+    end
+
+    # Used for setting an object in the attributes hash. If nil is provided the
+    # default will get returned if it exists.
+    def set(object)
+      type.set(object)
+    end
+
+    # Used for retrieving the object out of the attributes hash.
+    def get(object)
+      type.get(object)
+    end
+
+    protected
+    # Slightly faster default check.
+    def copy
+      @copyable ? @default.dup : @default
+    end
+  end
+end

data/lib/mongoid/fields.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Fields #:nodoc
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        # Set up the class attributes that must be available to all subclasses.
+        # These include defaults, fields
+        class_inheritable_accessor :fields
+
+        self.fields = {}
+
+        delegate :defaults, :fields, :to => "self.class"
+      end
+    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.
+      #
+      # Options:
+      #
+      # name: The name of the field, as a +Symbol+.
+      # options: A +Hash+ of options to supply to the +Field+.
+      #
+      # Example:
+      #
+      # <tt>field :score, :default => 0</tt>
+      def field(name, options = {})
+        access = name.to_s
+        set_field(access, options)
+      end
+
+      # Returns the default values for the fields on the document
+      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
+
+      protected
+      # Define a field attribute for the +Document+.
+      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.
+      def create_accessors(name, meth, options = {})
+        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
+  end
+end

data/lib/mongoid/finders.rb

@@ -0,0 +1,144 @@
+# 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, :avg, :excludes, :limit, :max, :min,
+      :not_in, :only, :order_by, :skip, :sum, :where ].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(:first, :conditions => { :attribute => "value" })</tt>
+    def count(*args)
+      Criteria.translate(self, *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, *args).limit(1).count == 1
+    end
+
+    # Helper to initialize a new +Criteria+ object for this class.
+    #
+    # Example:
+    #
+    # <tt>Person.criteria</tt>
+    def criteria
+      Criteria.new(self)
+    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.
+    #
+    # <tt>Person.find(:first, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(:all, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(Mongo::ObjectId.new.to_s)</tt>
+    def find(*args)
+      raise Errors::InvalidOptions.new("Calling Document#find with nil is invalid") if args[0].nil?
+      type = args.delete_at(0) if args[0].is_a?(Symbol)
+      criteria = Criteria.translate(self, *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, params).paginate
+    end
+
+    protected
+    # Find the first object or create/initialize it.
+    def find_or(method, attrs = {})
+      first(:conditions => attrs) || send(method, attrs)
+    end
+  end
+end

data/lib/mongoid/identity.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Identity #:nodoc:
+    class << self
+      # Create the identity for the +Document+.
+      #
+      # The id will be set in either in the form of a Mongo
+      # +ObjectId+ or a composite key set up by defining a key on the document.
+      #
+      # The _type will be set to the document's class name.
+      def create(doc)
+        identify(doc); type(doc); doc
+      end
+
+      protected
+      # Return the proper id for the document.
+      def generate_id
+        id = BSON::ObjectId.new
+        Mongoid.use_object_ids ? id : id.to_s
+      end
+
+      # Set the id for the document.
+      def identify(doc)
+        doc.id = compose(doc).join(" ").identify if doc.primary_key
+        doc.id = generate_id if doc.id.blank?
+      end
+
+      # Set the _type field on the document.
+      def type(doc)
+        doc._type = doc.class.name if doc.hereditary?
+      end
+
+      # Generates the composite key for a document.
+      def compose(doc)
+        doc.primary_key.collect { |key| doc.attributes[key] }.reject { |val| val.nil? }
+      end
+    end
+  end
+end

data/lib/mongoid/indexes.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Indexes #:nodoc
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+
+        cattr_accessor :indexed
+        self.indexed = false
+      end
+    end
+
+    module ClassMethods #:nodoc
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      def add_indexes
+        if hereditary && !indexed
+          self._collection.create_index(:_type, :unique => false, :background => true)
+          self.indexed = true
+        end
+      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 })
+        collection.create_index(name, options)
+      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/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,26 @@
+# 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 == value
+      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