mongoid-pre 2.0.0.beta1

data/lib/mongoid/fields.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Fields #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      # 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
+
+    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,136 @@
+# 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
+
+    # 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 = Mongo::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 unless doc.id
+      end
+
+      # Set the _type field on the document.
+      def type(doc)
+        doc._type = doc.class.name if Mongoid.persist_types
+      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,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Indexes #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :indexed
+      self.indexed = false
+    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
+        unless indexed
+          self._collection.create_index(:_type, false)
+          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[:unique])
+      end
+    end
+  end
+end

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/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/matchers.rb

@@ -0,0 +1,36 @@
+# 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:
+  module Matchers
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    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.
+    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/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